static CassieqCredentials key(
      final AccountName accountName, final AccountKey accountKey, final Clock requestClock) {

    return request -> {
      final Instant now = requestClock.now();

      final SignedRequestSignatureGenerator requestParameters =
          new SignedRequestSignatureGenerator(
              accountName,
              request.method(),
              request.url().getPath(),
              now.toDateTime(DateTimeZone.UTC));

      final String signature =
          requestParameters.computeSignature(MacProviders.HmacSha256(accountKey));

      final String requestTime = SignatureGenerator.formatDateTime(now);

      return request
          .newBuilder()
          .header("Authorization", "Signed " + signature)
          .header(StandardAuthHeaders.RequestTime.getHeaderName(), requestTime)
          .build();
    };
  }
 @Override
 public int hashCode() {
   int result = hostname.hashCode();
   result = 31 * result + from.hashCode();
   result = 31 * result + to.hashCode();
   return result;
 }
 // Get a beginning-of-week time for consistent tariff evaluation
 private Instant getNextSunday() {
   Instant result = getNowInstant();
   int hour = result.get(DateTimeFieldType.hourOfDay());
   if (hour > 0) result = result.plus((24 - hour) * TimeService.HOUR);
   int day = result.get(DateTimeFieldType.dayOfWeek());
   result = result.plus((7 - day) * TimeService.DAY);
   return result;
 }
 /** Advance the watermark to the specified time, firing any timers that should fire. */
 public void advanceWatermark(Instant newWatermark) throws Exception {
   Preconditions.checkState(
       !newWatermark.isBefore(watermark),
       "Cannot move watermark time backwards from %s to %s",
       watermark.getMillis(),
       newWatermark.getMillis());
   logInteraction("Advancing watermark to %d", newWatermark.getMillis());
   watermark = newWatermark;
   timerInternals.advanceWatermark(runner, newWatermark);
 }
 /** Advance the processing time to the specified time, firing any timers that should fire. */
 public void advanceProcessingTime(Instant newProcessingTime) throws Exception {
   Preconditions.checkState(
       !newProcessingTime.isBefore(processingTime),
       "Cannot move processing time backwards from %s to %s",
       processingTime.getMillis(),
       newProcessingTime.getMillis());
   logInteraction("Advancing processing time to %d", newProcessingTime.getMillis());
   processingTime = newProcessingTime;
   timerInternals.advanceProcessingTime(runner, newProcessingTime);
 }
 public Instant minimumWatermarkHold() {
   Instant minimum = null;
   for (State storage : inMemoryState.values()) {
     if (storage instanceof WatermarkStateInternal) {
       Instant hold = ((WatermarkStateInternal) storage).get().read();
       if (minimum == null || (hold != null && hold.isBefore(minimum))) {
         minimum = hold;
       }
     }
   }
   return minimum;
 }
  /**
   * Handle an account state warning produced by ldaptive account state machinery.
   *
   * <p>Override this method to provide custom warning message handling.
   *
   * @param warning the account state warning messages.
   * @param response Ldaptive authentication response.
   * @param configuration Password policy configuration.
   * @param messages Container for messages produced by account state warning handling.
   */
  protected void handleWarning(
      final AccountState.Warning warning,
      final AuthenticationResponse response,
      final LdapPasswordPolicyConfiguration configuration,
      final List<Message> messages) {

    logger.debug("Handling warning {}", warning);
    if (warning == null) {
      logger.debug("Account state warning not defined");
      return;
    }

    final Calendar expDate = warning.getExpiration();
    final Days ttl = Days.daysBetween(Instant.now(), new Instant(expDate));
    logger.debug(
        "Password expires in {} days. Expiration warning threshold is {} days.",
        ttl.getDays(),
        configuration.getPasswordWarningNumberOfDays());
    if (configuration.isAlwaysDisplayPasswordExpirationWarning()
        || ttl.getDays() < configuration.getPasswordWarningNumberOfDays()) {
      messages.add(
          new PasswordExpiringWarningMessage(
              "Password expires in {0} days. Please change your password at <href=\"{1}\">{1}</a>",
              ttl.getDays(), configuration.getPasswordPolicyUrl()));
    }
    if (warning.getLoginsRemaining() > 0) {
      messages.add(
          new Message(
              "password.expiration.loginsRemaining",
              "You have {0} logins remaining before you MUST change your password.",
              warning.getLoginsRemaining()));
    }
  }
Beispiel #8
0
 public void pause() {
   if (!isActive()) {
     throw new IllegalStateException("already non-active");
   }
   intervals.add(new Interval(starttime, Instant.now()));
   starttime = null;
 }
Beispiel #9
0
 @Override
 public void addField(TemporalElementaryDataItem di, Instant t) throws IOException {
   writeSeparator();
   if (t != null) {
     addRawData(Long.toString(t.getMillis()));
   }
 }
Beispiel #10
0
 public void setDate(Instant date) {
   if (date == null) {
     this.date = null;
   } else {
     this.date = date.toString(DATE_FORMAT);
   }
 }
 // Returns the next date/time when the given shift index will occur
 Instant indexToInstant(int index) {
   Instant now = getNowInstant();
   int probe = index;
   // get the probe within the shift schedule
   while (probe < 0) {
     probe += shiftSchedule.length;
   }
   while (probe > shiftSchedule.length) {
     probe -= shiftSchedule.length;
   }
   int nowIndex = indexOfShift(now);
   if (nowIndex <= index) {
     return (now.plus(TimeService.HOUR * (index - nowIndex)));
   }
   return (now.plus(TimeService.HOUR * (shiftSchedule.length + index - nowIndex)));
 }
  @Transactional
  @Override
  public LoadResponse loadGoods(final GoodPayload payload) {
    final long timeInMillis = Instant.now().getMillis();

    LoadResponse response = new LoadResponse(timeInMillis);
    for (final Map.Entry<Long, Integer> entry : payload.getGoods().entrySet()) {
      namedJdbcTemplate
          .getJdbcOperations()
          .batchUpdate(
              QUERY_INSERT_GOOD,
              new BatchPreparedStatementSetter() {
                @Override
                public void setValues(PreparedStatement ps, int i) throws SQLException {
                  ps.setTimestamp(1, new Timestamp(timeInMillis), tzUTC);
                  ps.setLong(2, entry.getKey());
                  ps.setBoolean(3, false);
                }

                @Override
                public int getBatchSize() {
                  return entry.getValue();
                }
              });
    }

    return response;
  }
  // Check production transactions
  @Test
  public void testProduction() {
    Instant exp = now.plus(TimeService.WEEK * 10);
    TariffSpecification tariffSpec =
        new TariffSpecification(broker, PowerType.PRODUCTION)
            .withExpiration(exp)
            .withMinDuration(TimeService.WEEK * 4)
            .withSignupPayment(-34.2)
            .withEarlyWithdrawPayment(35.0)
            .addRate(new Rate().withValue(0.102));
    tariff = new Tariff(tariffSpec);
    tariff.init();

    // subscribe and consume in the first timeslot
    TariffSubscription tsub = tariffMarketService.subscribeToTariff(tariff, customer, 4);
    assertEquals("four customers committed", 4, tsub.getCustomersCommitted());
    tsub.usePower(-244.6); // production
    assertEquals("correct total usage", -244.6 / 4, tsub.getTotalUsage(), 1e-6);
    assertEquals("correct realized price", 0.102, tariff.getRealizedPrice(), 1e-6);
    // def txs = TariffTransaction.findAllByPostedTime(timeService.currentTime);
    // assertEquals("two transactions", 2, txs.size())
    // TariffTransaction ttx = TariffTransaction.findByPostedTimeAndTxType(timeService.currentTime,
    // TariffTransactionType.SIGNUP)
    // assertNotNull("found signup tx", ttx)
    // assertEquals("correct charge", -34.2 * 4, ttx.charge, 1e-6)
    // ttx = TariffTransaction.findByPostedTimeAndTxType(timeService.currentTime,
    // TariffTransactionType.PRODUCE)
    // assertNotNull("found production tx", ttx)
    // assertEquals("correct amount", -244.6, ttx.quantity)
    // assertEquals("correct charge", -0.102 * 244.6, ttx.charge, 1e-6)
  }
  @Override
  public View getView(int position, View convertView, ViewGroup parent) {
    if (convertView == null) {
      // inflate the layout
      LayoutInflater inflater = ((Activity) mContext).getLayoutInflater();
      convertView = inflater.inflate(layoutResourceId, parent, false);
    }

    // object item based on the position
    final Event event = data.get(position);
    final TextView userNameView = (TextView) convertView.findViewById(R.id.user_text);

    cloudStore.lookUpUserByUid(
        event.getUser(),
        new Callback<User>() {
          @Override
          public void receive(User user) {
            userNameView.setText(user.getGivenName());
          }
        });

    TextView time = (TextView) convertView.findViewById(R.id.time_text);
    time.setText(
        PeriodicalFormatter.printFriendlyDate(new Instant(event.getMillis()), Instant.now()));

    return convertView;
  }
Beispiel #15
0
  /**
   * behaviour undefined if interval list is unsorted any {@code null} input is interpreted as a
   * non-bound in that direction
   *
   * @param focusStart
   * @param focusEnd
   * @return
   */
  public Duration getTimeSpentInInterval(LocalDate focusStart, LocalDate focusEnd) {
    Instant startInst, endInst;
    if (intervals.size() == 0 && !isActive()) { // #
      return Duration.ZERO;
    }
    if (focusStart == null) {
      startInst =
          intervals.size() == 0
              ? starttime // != null because #
              : intervals.get(0).getStart().toInstant();
    } else {
      startInst = focusStart.toDateTimeAtStartOfDay().toInstant();
    }
    if (focusEnd == null) {
      endInst =
          isActive()
              ? Instant.now()
              // v intervals.size() != 0 because #
              : intervals.get(intervals.size() - 1).getEnd().toInstant(); // TODO
    } else {
      endInst = focusEnd.toDateTimeAtStartOfDay().toInstant();
    }
    Interval focus = new Interval(startInst, endInst);

    return getTimeSpentInInterval(focus);
  }
 // reduce duration by one on each tick of the clock
 void tick() {
   duration -= 1;
   if (duration < 0) {
     log.error(
         getName() + "SE start at " + start.toString() + " ticked past duration " + duration);
   }
   usageIndex += 1;
 }
Beispiel #17
0
 public void setDonity(boolean done) {
   if (!isDone() && done) {
     this.done = Instant.now();
   }
   if (isDone() && !done) {
     this.done = null;
   }
 }
Beispiel #18
0
  protected boolean isPersonProtected(Person person) {
    if (person.getNavnebeskyttelsestartdato() == null) return false;

    // We have to make the guard above to avoid null being passed into the
    // Instant
    // it is converted to the beginning of the era.

    Preconditions.checkState(
        person.getNavnebeskyttelseslettedato() != null,
        "The protection end date was not present. This is most unexpected and a programming error.");

    Instant protectionStart = new Instant(person.getNavnebeskyttelsestartdato());
    Instant protectionEnd = new Instant(person.getNavnebeskyttelseslettedato());

    return protectionStart.isEqualNow()
        || (protectionStart.isBeforeNow() && protectionEnd.isAfterNow());
  }
  // subscription withdrawal without and with penalty
  @Test
  public void testEarlyWithdraw() {
    Instant exp = now.plus(TimeService.WEEK * 10);
    TariffSpecification tariffSpec =
        new TariffSpecification(broker, PowerType.CONSUMPTION)
            .withExpiration(exp)
            .withMinDuration(TimeService.WEEK * 4)
            .withSignupPayment(-33.2)
            .withEarlyWithdrawPayment(42.1)
            .addRate(new Rate().withValue(0.121));
    tariff = new Tariff(tariffSpec);
    tariff.init();
    TariffSubscription tsub = tariffMarketService.subscribeToTariff(tariff, customer, 5);

    // move time forward 2 weeks, withdraw 2 customers
    Instant wk2 = now.plus(TimeService.WEEK * 2);
    timeService.setCurrentTime(wk2);
    tsub.unsubscribe(2);
    verify(mockAccounting)
        .addTariffTransaction(
            TariffTransaction.Type.WITHDRAW, tariff, customer.getCustomerInfo(), 2, 0.0, 42.1 * 2);
    // def txs = TariffTransaction.findAllByPostedTime(wk2)
    // assertEquals("one transaction", 1, txs.size())
    // assertEquals("correct txType", TariffTransactionType.WITHDRAW, txs[0].txType)
    // assertEquals("correct charge", 42.1*2, txs[0].charge)
    assertEquals("three customers committed", 3, tsub.getCustomersCommitted());

    // move time forward another week, add 4 customers and drop 1
    Instant wk3 = now.plus(TimeService.WEEK * 2 + TimeService.HOUR * 6);
    timeService.setCurrentTime(wk3);
    TariffSubscription tsub1 = tariffMarketService.subscribeToTariff(tariff, customer, 4);
    assertEquals("same subscription", tsub, tsub1);
    tsub1.unsubscribe(1);
    // txs = TariffTransaction.findAllByPostedTime(wk3)
    // assertEquals("two transactions", 2, txs.size())
    // TariffTransaction ttx = TariffTransaction.findByPostedTimeAndTxType(timeService.currentTime,
    //
    // TariffTransactionType.SIGNUP)
    // assertNotNull("found signup tx", ttx)
    // assertEquals("correct charge", -33.2 * 4, ttx.charge)
    // ttx = TariffTransaction.findByPostedTimeAndTxType(timeService.currentTime,
    //                                                  TariffTransactionType.WITHDRAW)
    // assertNotNull("found withdraw tx", ttx)
    // assertEquals("correct charge", 42.1, ttx.charge)
    assertEquals("six customers committed", 6, tsub1.getCustomersCommitted());
  }
  // Check consumption transactions
  @Test
  public void testConsumption() {
    Instant exp = now.plus(TimeService.WEEK * 10);
    TariffSpecification tariffSpec =
        new TariffSpecification(broker, PowerType.CONSUMPTION)
            .withExpiration(exp)
            .withMinDuration(TimeService.WEEK * 4)
            .withSignupPayment(-33.2)
            .addRate(new Rate().withValue(0.121));
    tariff = new Tariff(tariffSpec);
    tariff.init();

    // subscribe and consume in the first timeslot
    TariffSubscription tsub = tariffMarketService.subscribeToTariff(tariff, customer, 4);
    assertEquals("four customers committed", 4, tsub.getCustomersCommitted());
    tsub.usePower(24.4); // consumption
    assertEquals("correct total usage", 24.4 / 4, tsub.getTotalUsage(), 1e-6);
    assertEquals("correct realized price", 0.121, tariff.getRealizedPrice(), 1e-6);
    // def txs = TariffTransaction.findAllByPostedTime(timeService.getCurrentTime());
    // assertEquals("two transactions", 2, txs.size())
    // TariffTransaction ttx =
    //    TariffTransaction.findByPostedTimeAndTxType(timeService.currentTime,
    // TariffTransactionType.SIGNUP)
    // assertNotNull("found signup tx", ttx)
    // assertEquals("correct charge", -33.2 * 4, ttx.charge, 1e-6)
    // ttx = TariffTransaction.findByPostedTimeAndTxType(timeService.currentTime,
    // TariffTransactionType.CONSUME)
    // assertNotNull("found consumption tx", ttx)
    // assertEquals("correct amount", 24.4, ttx.quantity)
    // assertEquals("correct charge", 0.121 * 24.4, ttx.charge, 1e-6)

    // just consume in the second timeslot
    Instant hour = now.plus(TimeService.HOUR);
    timeService.setCurrentTime(hour);
    tsub.usePower(32.8); // consumption
    assertEquals("correct total usage", (24.4 + 32.8) / 4, tsub.getTotalUsage(), 1e-6);
    assertEquals("correct realized price", 0.121, tariff.getRealizedPrice(), 1e-6);
    // txs = TariffTransaction.findAllByPostedTime(timeService.getCurrentTime())
    // assertEquals("one transaction", 1, txs.size())
    // ttx = TariffTransaction.findByPostedTimeAndTxType(timeService.getCurrentTime(),
    // TariffTransactionType.CONSUME)
    // assertNotNull("found consumption tx", ttx)
    // assertEquals("correct amount", 32.8, ttx.quantity)
    // assertEquals("correct charge", 0.121 * 32.8, ttx.charge, 1e-6)
  }
 public void injectElement(InputT value, Instant timestamp) throws Exception {
   Collection<W> windows =
       windowFn.assignWindows(
           new TriggerTester.StubAssignContext<W>(
               windowFn, value, timestamp, Arrays.asList(GlobalWindow.INSTANCE)));
   logInteraction(
       "Element %s at time %d put in windows %s", value, timestamp.getMillis(), windows);
   runner.processElement(WindowedValue.of(value, timestamp, windows, PaneInfo.NO_FIRING));
 }
 // Returns the ShiftEnergy instance for the current time
 // Note that for this to work, the ShiftEnergy.tick() method
 // must be called once/timeslot.
 ShiftEnergy getCurrentNeed(Instant when) {
   if (null == needs) return null;
   for (int i = 0; i < needs.length; i++) {
     // if it's the last one, return it.
     if ((i == needs.length - 1) || (needs[i + 1].getStart().isAfter(when))) {
       return needs[i];
     }
   }
   // should never get here
   log.error(
       getName()
           + " at "
           + when.toString()
           + " ran off end of plan length "
           + size
           + " starting "
           + start.toString());
   return null;
 }
  @Override
  public void flatMap(IN value, Collector<WindowedValue<OUT>> out) throws Exception {

    @SuppressWarnings("unchecked")
    OUT voidValue = (OUT) VoidCoderTypeSerializer.VoidValue.INSTANCE;
    for (byte[] element : elements) {
      ByteArrayInputStream bai = new ByteArrayInputStream(element);
      OUT outValue = coder.decode(bai, Coder.Context.OUTER);

      if (outValue == null) {
        out.collect(
            WindowedValue.of(voidValue, Instant.now(), GlobalWindow.INSTANCE, PaneInfo.NO_FIRING));
      } else {
        out.collect(
            WindowedValue.of(outValue, Instant.now(), GlobalWindow.INSTANCE, PaneInfo.NO_FIRING));
      }
    }

    out.close();
  }
  public void testSimpleStore() throws SQLException {
    SessionFactory factory = getSessionFactory();

    Session session = factory.openSession();

    for (int i = 0; i < writeReadTimes.length; i++) {
      Instant writeReadTime = writeReadTimes[i];

      ThingWithInstant thing = new ThingWithInstant();
      thing.setId(i);
      thing.setInstant(writeReadTime);

      session.save(thing);
    }

    session.flush();
    session.connection().commit();
    session.close();

    for (int i = 0; i < writeReadTimes.length; i++) {
      Instant writeReadTime = writeReadTimes[i];

      session = factory.openSession();
      ThingWithInstant thingReread =
          (ThingWithInstant) session.get(ThingWithInstant.class, new Integer(i));

      assertNotNull("get failed - thing#'" + i + "'not found", thingReread);
      assertNotNull("get failed - returned null", thingReread.getInstant());

      Instant reReadTime = thingReread.getInstant();
      if (writeReadTime.getMillis() != reReadTime.getMillis()) {
        fail(
            "get failed - returned different date. expected "
                + writeReadTime
                + " was "
                + thingReread.getInstant());
      }
    }

    session.close();
  }
 protected void checkTimestamp(WindowedValue<IN> ref, Instant timestamp) {
   if (timestamp.isBefore(ref.getTimestamp().minus(doFn.getAllowedTimestampSkew()))) {
     throw new IllegalArgumentException(
         String.format(
             "Cannot output with timestamp %s. Output timestamps must be no earlier than the "
                 + "timestamp of the current input (%s) minus the allowed skew (%s). See the "
                 + "DoFn#getAllowedTimestmapSkew() Javadoc for details on changing the allowed skew.",
             timestamp,
             ref.getTimestamp(),
             PeriodFormat.getDefault().print(doFn.getAllowedTimestampSkew().toPeriod())));
   }
 }
Beispiel #26
0
  // set commitment leadtime to a larger number and make sure ordering
  // behavior is correct
  @Test
  public void testGenerateOrders2() {
    // set up the genco with commitment leadtime=3
    PluginConfig config = new PluginConfig("Genco", "").addConfiguration("commitmentLeadtime", "3");
    genco.configure(config); // all defaults
    // capture orders
    final ArrayList<Order> orderList = new ArrayList<Order>();
    doAnswer(
            new Answer() {
              public Object answer(InvocationOnMock invocation) {
                Object[] args = invocation.getArguments();
                orderList.add((Order) args[0]);
                return null;
              }
            })
        .when(mockProxy)
        .routeMessage(isA(Order.class));
    // set up some timeslots
    Timeslot ts0 = timeslotRepo.makeTimeslot(start);
    ts0.disable();
    assertEquals("first ts has sn=0", 0, ts0.getSerialNumber());
    timeslotRepo.makeTimeslot(start.plus(TimeService.HOUR));
    timeslotRepo.makeTimeslot(start.plus(TimeService.HOUR * 2));
    timeslotRepo.makeTimeslot(start.plus(TimeService.HOUR * 3));
    timeslotRepo.makeTimeslot(start.plus(TimeService.HOUR * 4));
    assertEquals("4 enabled timeslots", 4, timeslotRepo.enabledTimeslots().size());

    // generate orders and check
    genco.generateOrders(start, timeslotRepo.enabledTimeslots());
    assertEquals("two orders", 2, orderList.size());
    Order first = orderList.get(0);
    assertEquals("first order for ts3", 3, first.getTimeslot().getSerialNumber());
    assertEquals("first order price", 1.0, first.getLimitPrice(), 1e-6);
    assertEquals("first order for 50 mwh", -100.0, first.getMWh(), 1e-6);
    Order second = orderList.get(1);
    assertEquals("second order for ts4", 4, second.getTimeslot().getSerialNumber());
    assertEquals("second order price", 1.0, second.getLimitPrice(), 1e-6);
    assertEquals("second order for 100 mwh", -100.0, second.getMWh(), 1e-6);
  }
Beispiel #27
0
 @Test
 public void testGenerateOrders() {
   // set up the genco
   PluginConfig config = new PluginConfig("Genco", "");
   genco.configure(config); // all defaults
   // capture orders
   final ArrayList<Order> orderList = new ArrayList<Order>();
   doAnswer(
           new Answer() {
             public Object answer(InvocationOnMock invocation) {
               Object[] args = invocation.getArguments();
               orderList.add((Order) args[0]);
               return null;
             }
           })
       .when(mockProxy)
       .routeMessage(isA(Order.class));
   // set up some timeslots
   Timeslot ts1 = timeslotRepo.makeTimeslot(start);
   ts1.disable();
   Timeslot ts2 = timeslotRepo.makeTimeslot(start.plus(TimeService.HOUR));
   Timeslot ts3 = timeslotRepo.makeTimeslot(start.plus(TimeService.HOUR * 2));
   assertEquals("2 enabled timeslots", 2, timeslotRepo.enabledTimeslots().size());
   // 50 mwh already sold in ts2
   MarketPosition posn2 = new MarketPosition(genco, ts2, -50.0);
   genco.addMarketPosition(posn2, ts2);
   // generate orders and check
   genco.generateOrders(start, timeslotRepo.enabledTimeslots());
   assertEquals("two orders", 2, orderList.size());
   Order first = orderList.get(0);
   assertEquals("first order for ts2", ts2, first.getTimeslot());
   assertEquals("first order price", 1.0, first.getLimitPrice(), 1e-6);
   assertEquals("first order for 50 mwh", -50.0, first.getMWh(), 1e-6);
   Order second = orderList.get(1);
   assertEquals("second order for ts3", ts3, second.getTimeslot());
   assertEquals("second order price", 1.0, second.getLimitPrice(), 1e-6);
   assertEquals("second order for 100 mwh", -100.0, second.getMWh(), 1e-6);
 }
  @Override
  protected QuartzBatchJobMetrics mmrBatchExecuteInternal(JobDataMap mergedDataMap) {
    Instant startInstant = Instant.now();

    ExecutionResultDetails executionDetails = executeJob();

    Instant endInstant = Instant.now();
    Duration duration = new Duration(startInstant, endInstant);
    QuartzBatchJobMetrics jobMetrics =
        new BaseQuartzBatchJobMetrics(
            startInstant,
            endInstant,
            duration,
            executionDetails.getNumberOfProcessedItems(),
            executionDetails.getNumberOfErroredItems(),
            executionDetails.getErrorItems());

    logger.info(
        "Finished {} finished in {} time",
        getJobDetailName(),
        ISODateTimeFormat.basicTime().print(duration.getMillis()));
    return jobMetrics;
  }
    @Override
    public boolean equals(Object o) {
      if (this == o) {
        return true;
      }
      if (o == null || getClass() != o.getClass()) {
        return false;
      }

      Key key = (Key) o;

      if (!from.equals(key.from)) {
        return false;
      }
      if (!hostname.equals(key.hostname)) {
        return false;
      }
      if (!to.equals(key.to)) {
        return false;
      }

      return true;
    }
 @Before
 public void setUp() {
   broker = new Broker("Joe");
   now = new DateTime(2011, 1, 10, 0, 0, 0, 0, DateTimeZone.UTC).toInstant();
   timeService.setCurrentTime(now);
   Instant exp = now.plus(TimeService.WEEK * 10);
   TariffSpecification tariffSpec =
       new TariffSpecification(broker, PowerType.CONSUMPTION)
           .withExpiration(exp)
           .withMinDuration(TimeService.WEEK * 8)
           .addRate(new Rate().withValue(0.121));
   tariff = new Tariff(tariffSpec);
   tariff.init();
   customerInfo = new CustomerInfo("Charley", 100);
   customer = new AbstractCustomer(customerInfo);
   reset(mockAccounting);
 }