def test_level_generation_steps(self):
        """
        Test that level generation steps are done
        """
        factory = mock()
        partitioner = mock()
        room_generator = mock()
        level_decorator = mock()
        stair_adder = mock()
        item_adder = mock()
        creature_adder = mock()
        rng = random.Random()

        portal = mock()

        section1 = mock()
        section2 = mock()

        when(partitioner).partition_level(any()).thenReturn([section1,
                                                             section2])

        level_context = LevelContext(size = (60, 40),
                                     floor_type = self.floor_rock,
                                     wall_type = -101,
                                     empty_floor = 0,
                                     empty_wall = self.wall_empty)

        generator = LevelGenerator(factory, partitioner, [room_generator],
                                   level_decorator, [stair_adder],
                                   item_adder, creature_adder,
                                   self.rng,
                                   level_context)

        generator.generate_level(portal)

        verify(partitioner).partition_level(any())
        verify(room_generator, times = 2).generate_room(any())
        verify(level_decorator).decorate_level(any())
        verify(creature_adder).add_creatures(any())
        verify(item_adder).add_items(any())
    def test_catacombs_generation(self):
        """
        Test that catacombs generator creates a fully connected level
        """
        factory = mock(ActionFactory)
        partitioner = GridPartitioner(['crypt'],
                                      1,
                                      1,
                                      self.rng)
        room_generator = CatacombsGenerator(self.floor_rock,
                                             self.wall_empty,
                                             ['crypt'],
                                             self.rng)
        level_decorator = mock()
        portal_adder = PortalAdder((1, 2),
                                  'crypt',
                                  mock(),
                                  self.rng)
        creature_adder = mock()
        item_adder = mock()

        portal = mock(Portal)

        generator = LevelGenerator(factory, partitioner, [room_generator],
                                   level_decorator, [portal_adder],
                                   item_adder,
                                   creature_adder,
                                   self.rng,
                                   LevelContext(size = (60, 40),
                                        floor_type = -2,
                                        wall_type = -101,
                                        empty_floor = 0,
                                        empty_wall = self.wall_empty))

        new_level = generator.generate_level(portal)

        assert_that(new_level, is_fully_accessible_via(self.wall_empty))