@Test
  public void all_valid_exits_are_retrieveable() {
    final Exit exit1 = mockery.mock(Exit.class, "exit1");
    final Exit exit2 = mockery.mock(Exit.class, "exit2");
    mockery.checking(
        new Expectations() {
          {
            allowing(exit1).visible();
            will(returnValue(true));
            ignoring(exit1);
            allowing(exit2).visible();
            will(returnValue(true));
            ignoring(exit2);
          }
        });
    List<Exit> exits = new ArrayList<Exit>();
    exits.add(exit1);
    exits.add(exit2);

    Location l = createLocation();
    l.addExit(exit1);
    l.addExit(exit2);

    assertEquals(exits, l.visibleExits());
  }
  @Test
  public void available_items_text_includes_only_visible_items() {
    final Item visibleItem = mockery.mock(Item.class, "visible item");
    final Item invisibleItem = mockery.mock(Item.class, "invisible item");
    mockery.checking(
        new Expectations() {
          {
            allowing(visibleItem).visible();
            will(returnValue(true));
            allowing(visibleItem).countableNounPrefix();
            will(returnValue("a"));
            allowing(visibleItem).midSentenceCasedName();
            will(returnValue("visible item"));
            ignoring(visibleItem);
            allowing(invisibleItem).visible();
            will(returnValue(false));
            allowing(invisibleItem).midSentenceCasedName();
            will(returnValue("invisible item"));
            ignoring(invisibleItem);
          }
        });
    Location l = new Location("", "Location description.", null, null);
    l.addItem(visibleItem);
    l.addItem(invisibleItem);

    assertEquals("There is a visible item here.\n", l.availableItemsText());
  }
  @Test
  public void actions_uses_action_factory_to_create_ExamineAnItem_action_for_all_visible_items() {
    final Item visibleItem = mockery.mock(Item.class, "visible item");
    final Item invisibleItem = mockery.mock(Item.class, "invisible item");
    final ActionFactory actionFactory = mockery.mock(ActionFactory.class);
    final Action examineAnItemAction = mockery.mock(Action.class);
    final List<Item> visibleItems = new ArrayList<Item>();
    visibleItems.add(visibleItem);
    mockery.checking(
        new Expectations() {
          {
            allowing(visibleItem).visible();
            will(returnValue(true));
            ignoring(visibleItem);
            allowing(invisibleItem).visible();
            will(returnValue(false));
            ignoring(invisibleItem);
            oneOf(actionFactory).createExamineAnItemAction(with(equal(visibleItems)));
            will(returnValue(examineAnItemAction));
            ignoring(actionFactory);
          }
        });
    Location l = new Location("", "", null, actionFactory);
    l.addItem(visibleItem);
    l.addItem(invisibleItem);

    List<Action> actions = l.actions();
    assertTrue(actions.size() > 0);
    assertThat(actions.get(0), is(examineAnItemAction));
  }
Пример #4
0
  @Test
  public void pickFruits() {
    final FruitTree mangoTree = context.mock(FruitTree.class);
    final Mango mango1 = new Mango();
    final Mango mango2 = new Mango();

    context.checking(
        new Expectations() {
          {
            oneOf(mangoTree).pickFruit(with(any(Collection.class)));
            will(
                new VoidAction() {
                  public Object invoke(Invocation invocation) {
                    @SuppressWarnings({"unchecked"})
                    Collection<Fruit> fruits = (Collection<Fruit>) invocation.getParameter(0);
                    fruits.add(mango1);
                    fruits.add(mango2);
                    return null;
                  }
                });
          }
        });

    Collection<Fruit> fruits = new FruitPicker().pickFruits(asList(mangoTree));

    assertEquals(asList(mango1, mango2), fruits);
  }
 @Test
 public void removing_all_items_from_a_location_removes_TakeAnItem_action_from_action_list() {
   final Item takeableItem = mockery.mock(Item.class);
   final ActionFactory actionFactory = mockery.mock(ActionFactory.class);
   final Location l = new Location("", "", null, actionFactory);
   mockery.checking(
       new Expectations() {
         {
           allowing(takeableItem).visible();
           will(returnValue(true));
           allowing(takeableItem).takeable();
           will(returnValue(true));
           ignoring(takeableItem);
           never(actionFactory)
               .createTakeAnItemAction(
                   with(any(List.class)),
                   with(any(UserInventory.class)),
                   with(any(ModelLocation.class)));
           ignoring(actionFactory);
         }
       });
   l.addItem(takeableItem);
   l.removeItem(takeableItem);
   l.actions();
 }
 @Test
 public void exits_that_havent_been_added_are_not_exitable() {
   final Exit exit = mockery.mock(Exit.class);
   mockery.checking(
       new Expectations() {
         {
           ignoring(exit);
         }
       });
   Location l = createLocation();
   assertFalse(l.exitable(exit));
 }
@RunWith(JMock.class)
public class FormatTransactionAsCsvRowTest {
  private final Mockery mockery = new Mockery();

  private final CsvFormat<LocalDate> dateFormat = mockery.mock(CsvFormat.class, "date format");
  private final CsvFormat<Category> categoryFormat =
      mockery.mock(CsvFormat.class, "category format");
  private final CsvFormat<Amount> amountFormat = mockery.mock(CsvFormat.class, "amount format");
  private final TransactionCsvFormat transactionCsvFormat =
      new TransactionCsvFormat(dateFormat, categoryFormat, amountFormat);

  private LocalDate anyNonNullDate = new LocalDate(2012, 11, 14);
  private Category anyNonNullCategory = new Category("Bowling Winnings");
  private Amount anyNonNullAmount = Amount.cents(250);

  @Test
  public void happyPath() throws Exception {
    mockery.checking(
        new Expectations() {
          {
            allowing(dateFormat).format(with(any(LocalDate.class)));
            will(returnValue("::the date::"));

            allowing(categoryFormat).format(with(any(Category.class)));
            will(returnValue("::the category::"));

            allowing(amountFormat).format(with(any(Amount.class)));
            will(returnValue("::the amount::"));
          }
        });

    final Transaction transaction =
        new Transaction(anyNonNullDate, anyNonNullCategory, anyNonNullAmount);
    final String rowText = transactionCsvFormat.format(transaction);
    assertThat(
        rowText,
        matches(
            Pattern.compile(
                "\\s*\"::the date::\","
                    + "\\s*\"::the category::\","
                    + "\\s*\"::the amount::\"\\s*")));
  }

  @Test
  public void nullTransaction() throws Exception {
    try {
      transactionCsvFormat.format(null);
      fail("How did you format a null transaction?!");
    } catch (ProgrammerMistake success) {
    }
  }
}
 @Test
 public void exit_destination_is_retrievable() {
   final Exit exit = mockery.mock(Exit.class);
   mockery.checking(
       new Expectations() {
         {
           allowing(exit).destination();
           will(returnValue("destination"));
           ignoring(exit);
         }
       });
   Location l = createLocation();
   assertEquals("destination", l.exitDestinationFor(exit));
 }
 @Test
 public void added_exit_makes_the_exit_exitable() {
   final Exit exit = mockery.mock(Exit.class);
   mockery.checking(
       new Expectations() {
         {
           allowing(exit).visible();
           will(returnValue(true));
           ignoring(exit);
         }
       });
   Location l = createLocation();
   l.addExit(exit);
   assertTrue(l.exitable(exit));
 }
 @Test
 public void non_visible_exits_are_not_exitable() {
   final Exit exit = mockery.mock(Exit.class);
   mockery.checking(
       new Expectations() {
         {
           allowing(exit).visible();
           will(returnValue(false));
           ignoring(exit);
         }
       });
   Location l = createLocation();
   l.addExit(exit);
   assertFalse(l.exitable(exit));
 }
  @Test
  public void label_is_target_item_name() {
    final Item item = mockery.mock(Item.class);
    mockery.checking(
        new Expectations() {
          {
            allowing(item).name();
            will(returnValue("Item name"));
            ignoring(item);
          }
        });
    UseWithSpecificItem action = new UseWithSpecificItem(null, item);

    assertEquals("Item name", action.label());
  }
 @Test
 public void non_visible_exits_are_not_in_the_exits_list() {
   final Exit exit = mockery.mock(Exit.class);
   mockery.checking(
       new Expectations() {
         {
           allowing(exit).visible();
           will(returnValue(false));
           ignoring(exit);
         }
       });
   Location l = createLocation();
   l.addExit(exit);
   assertEquals(0, l.visibleExits().size());
 }
  @Test
  public void passes_UserInventory_to_created_object() {
    final UserInventory inventory = mockery.mock(UserInventory.class);
    Location l = (Location) new LocationFactory(inventory, null).create();

    assertEquals(inventory, l.inventory());
  }
Пример #14
0
  @Test
  public void decrement_Execute() {
    // Arrange
    mockery.checking(
        new Expectations() {
          {
            oneOf(executionContext).decrement();
          }
        });

    // Act
    Instruction.DECREMENT.execute(executionContext);

    // Assert
    mockery.assertIsSatisfied();
  }
Пример #15
0
  @Test
  public void testAndJumpBackward_Execute() {
    // Arrange
    mockery.checking(
        new Expectations() {
          {
            oneOf(executionContext).testAndJumpBackward();
          }
        });

    // Act
    Instruction.TEST_AND_JUMP_BACKWARD.execute(executionContext);

    // Assert
    mockery.assertIsSatisfied();
  }
  @Test
  public void happyPath() throws Exception {
    mockery.checking(
        new Expectations() {
          {
            allowing(dateFormat).format(with(any(LocalDate.class)));
            will(returnValue("::the date::"));

            allowing(categoryFormat).format(with(any(Category.class)));
            will(returnValue("::the category::"));

            allowing(amountFormat).format(with(any(Amount.class)));
            will(returnValue("::the amount::"));
          }
        });

    final Transaction transaction =
        new Transaction(anyNonNullDate, anyNonNullCategory, anyNonNullAmount);
    final String rowText = transactionCsvFormat.format(transaction);
    assertThat(
        rowText,
        matches(
            Pattern.compile(
                "\\s*\"::the date::\","
                    + "\\s*\"::the category::\","
                    + "\\s*\"::the amount::\"\\s*")));
  }
Пример #17
0
  @Test
  public void output_Execute() {
    // Arrange
    mockery.checking(
        new Expectations() {
          {
            oneOf(executionContext).ouput();
          }
        });

    // Act
    Instruction.OUTPUT.execute(executionContext);

    // Assert
    mockery.assertIsSatisfied();
  }
 @Test
 public void a_location_without_items_does_not_need_a_TakeAnItem_action() {
   final ActionFactory actionFactory = mockery.mock(ActionFactory.class);
   final Location l = new Location("", "", null, actionFactory);
   mockery.checking(
       new Expectations() {
         {
           never(actionFactory)
               .createTakeAnItemAction(
                   with(any(List.class)),
                   with(any(UserInventory.class)),
                   with(any(ModelLocation.class)));
           ignoring(actionFactory);
         }
       });
   l.actions();
 }
Пример #19
0
  @Test
  public void moveBackward_Execute() {

    // Arrange
    mockery.checking(
        new Expectations() {
          {
            oneOf(executionContext).moveBackward();
          }
        });

    // Act
    Instruction.MOVE_BACKWARD.execute(executionContext);

    // Assert
    mockery.assertIsSatisfied();
  }
  @Test
  public void using_an_item_causes_the_target_item_to_be_used() {
    final Item original = mockery.mock(Item.class, "original");
    final Item target = mockery.mock(Item.class, "target");
    mockery.checking(
        new Expectations() {
          {
            allowing(original).id();
            will(returnValue("originalid"));
            ignoring(original);
            oneOf(target).useWith(original);
            ignoring(target);
          }
        });
    UseWithSpecificItem action = new UseWithSpecificItem(original, target);

    action.trigger();
  }
Пример #21
0
  @Test
  public void noOperation_Execute() {
    // Arrange

    // Act
    Instruction.NO_OPERATION.execute(executionContext);

    // Assert
    mockery.assertIsSatisfied();
  }
  @Test
  public void willLimitBidToMaximum() throws Exception {
    context.checking(
        new Expectations() {
          {
            exactly(1).of(auction).bid(maximumBid);
          }
        });

    sniper.bidAccepted(maximumBid.subtract(new Money(1)));
  }
  @Test
  public void willAnnounceItHasFinishedIfPriceGoesAboveMaximum() {
    context.checking(
        new Expectations() {
          {
            exactly(1).of(listener).sniperFinished(sniper);
          }
        });

    sniper.bidAccepted(unbeatableBid);
  }
  @Test
  public void willNotBidPriceGreaterThanMaximum() throws Exception {
    context.checking(
        new Expectations() {
          {
            ignoring(listener);
            never(auction).bid(with(any(Money.class)));
          }
        });

    sniper.bidAccepted(unbeatableBid);
  }
  @Test
  public void using_an_item_changes_the_user_text_to_the_use_with_message_of_the_target_item() {
    final Item original = mockery.mock(Item.class, "original");
    final Item target = mockery.mock(Item.class, "target");
    mockery.checking(
        new Expectations() {
          {
            ignoring(original);
            allowing(target).canBeUsedWith(original);
            will(returnValue(true));
            allowing(target).useWith(original);
            will(returnValue("use with text"));
            ignoring(target);
          }
        });
    UseWithSpecificItem action = new UseWithSpecificItem(original, target);

    action.trigger();

    assertThat(action.userText(), stringEndsWith("use with text"));
  }
  @Test
  public void triesToBeatTheLatestHighestBid() throws Exception {
    final Money expectedBid = beatableBid.add(increment);

    context.checking(
        new Expectations() {
          {
            oneOf(auction).bid(expectedBid);
          }
        });

    sniper.bidAccepted(beatableBid);
  }
 @Test
 public void location_action_to_take_an_item_is_not_included_if_only_untakeable_items_available() {
   final Item untakeableItem = mockery.mock(Item.class, "untakeable item");
   final ActionFactory actionFactory = mockery.mock(ActionFactory.class);
   final Location l = new Location("", "", null, actionFactory);
   mockery.checking(
       new Expectations() {
         {
           allowing(untakeableItem).visible();
           will(returnValue(true));
           allowing(untakeableItem).takeable();
           will(returnValue(false));
           ignoring(untakeableItem);
           never(actionFactory)
               .createTakeAnItemAction(
                   with(any(List.class)),
                   with(any(UserInventory.class)),
                   with(any(ModelLocation.class)));
           ignoring(actionFactory);
         }
       });
   l.addItem(untakeableItem);
   l.actions();
 }
  @Test
  public void catchesExceptionsAndReportsThemToErrorListener() throws Exception {
    final AuctionException exception = new AuctionException("test");

    context.checking(
        new Expectations() {
          {
            allowing(auction).bid(with(any(Money.class)));
            will(throwException(exception));
            exactly(1).of(listener).sniperBidFailed(sniper, exception);
          }
        });

    sniper.bidAccepted(beatableBid);
  }
  @Test
  public void modelBlowsUpInAnUnavoidableWay() throws Exception {
    mockery.checking(
        new Expectations() {
          {
            allowing(browseTransactionsModel).findAllTransactions();
            will(throwException(new InternalStorageException()));
          }
        });

    pressExportAllTransactionsButton(browseTransactionsActivity);

    assertLastToastMatchesRegex(
        "Something strange just happened. Try again. You might need to reinstall the "
            + "application. I feel embarrassed and ashamed.");
  }
  @Test
  public void exportWhateverTheModelProvides() throws Exception {
    final List<Transaction> anyNonEmptyListOfTransactions =
        ObjectMother.anyNonEmptyListOfTransactions();

    mockery.checking(
        new Expectations() {
          {
            allowing(browseTransactionsModel).findAllTransactions();
            will(returnValue(anyNonEmptyListOfTransactions));

            ignoring(androidDevicePublicStorageGateway);

            oneOf(exportAllTransactionsAction).execute(with(anyNonEmptyListOfTransactions));
          }
        });

    pressExportAllTransactionsButton(browseTransactionsActivity);
  }