@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 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));
  }
 @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();
 }
  @Test
  public void only_visible_items_can_be_spoken_to() {
    Item visibleItem = mock(Item.class);
    when(visibleItem.canTalkTo()).thenReturn(true);
    when(visibleItem.visible()).thenReturn(true);
    Item notVisibleItem = mock(Item.class);
    when(notVisibleItem.canTalkTo()).thenReturn(true);
    when(notVisibleItem.visible()).thenReturn(false);
    TalkToAction talkToAction = mock(TalkToAction.class);
    ActionFactory actionFactory = mock(ActionFactory.class);
    when(actionFactory.createTalkToAction(visibleItem)).thenReturn(talkToAction);

    Location l = new Location("", "", null, actionFactory);
    l.addItem(visibleItem);
    l.addItem(notVisibleItem);

    assertThat(l.actions(), hasItem(talkToAction));
    verify(actionFactory, never()).createTalkToAction(notVisibleItem);
  }
  @Test
  public void actions_uses_action_factory_to_create_TalkTo_action_for_all_canTalkTo_items() {
    Item talkableItem = mock(Item.class);
    when(talkableItem.canTalkTo()).thenReturn(true);
    when(talkableItem.visible()).thenReturn(true);
    Item notTalkPhraseSourceItem = mock(Item.class);
    when(notTalkPhraseSourceItem.canTalkTo()).thenReturn(false);
    when(notTalkPhraseSourceItem.visible()).thenReturn(true);
    TalkToAction talkToAction = mock(TalkToAction.class);
    ActionFactory actionFactory = mock(ActionFactory.class);
    when(actionFactory.createTalkToAction(talkableItem)).thenReturn(talkToAction);

    Location l = new Location("", "", null, actionFactory);
    l.addItem(talkableItem);
    l.addItem(notTalkPhraseSourceItem);

    assertThat(l.actions(), hasItem(talkToAction));
    verify(actionFactory, never()).createTalkToAction(notTalkPhraseSourceItem);
  }
 @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();
 }