def test_get_all(self):
     self.mox.StubOutWithMock(db, 'aggregate_get_all')
     db.aggregate_get_all(self.context).AndReturn([fake_aggregate])
     self.mox.ReplayAll()
     aggs = aggregate.AggregateList.get_all(self.context)
     self.assertEqual(1, len(aggs))
     self.compare_obj(aggs[0], fake_aggregate, subs=SUBS)

 def test_migration(self):
     db.aggregate_create(self.context, {'name': 'foo'})
     main_aggregates_len = len(db.aggregate_get_all(self.context))
     match, done = aggregate_obj.migrate_aggregates(self.context, 50)
     self.assertEqual(1, main_aggregates_len)
     self.assertEqual(main_aggregates_len, match)
     self.assertEqual(main_aggregates_len, done)
     self.assertEqual(0, len(db.aggregate_get_all(self.context)))
     self.assertEqual(main_aggregates_len,
                      len(aggregate_obj.AggregateList.get_all(
                                                             self.context)))

 def test_aggregate_delete(self):
     """Ensure we can delete an aggregate."""
     ctxt = context.get_admin_context()
     result = _create_aggregate(context=ctxt, metadata=None)
     db.aggregate_delete(ctxt, result['id'])
     expected = db.aggregate_get_all(ctxt, read_deleted='no')
     self.assertEqual(0, len(expected))

 def test_aggregate_delete(self):
     """Ensure we can delete an aggregate."""
     ctxt = context.get_admin_context()
     result = _create_aggregate(context=ctxt, metadata=None)
     db.aggregate_delete(ctxt, result['id'])
     expected = db.aggregate_get_all(ctxt, read_deleted='no')
     self.assertEqual(0, len(expected))
     aggregate = db.aggregate_get(ctxt, result['id'], read_deleted='yes')
     self.assertEqual(aggregate["operational_state"], "dismissed")

 def test_aggregate_delete(self):
     """Ensure we can delete an aggregate."""
     ctxt = context.get_admin_context()
     result = _create_aggregate(context=ctxt, metadata=None)
     db.aggregate_delete(ctxt, result["id"])
     expected = db.aggregate_get_all(ctxt)
     self.assertEqual(0, len(expected))
     aggregate = db.aggregate_get(ctxt.elevated(read_deleted="yes"), result["id"])
     self.assertEqual(aggregate.deleted, True)

 def test_aggregate_get_all(self):
     """Ensure we can get all aggregates."""
     ctxt = context.get_admin_context()
     counter = 3
     for c in xrange(counter):
         _create_aggregate(context=ctxt,
                           values={'name': 'fake_aggregate_%d' % c,
                                   'availability_zone': 'fake_avail_zone'},
                           metadata=None)
     results = db.aggregate_get_all(ctxt)
     self.assertEqual(len(results), counter)

 def test_aggregate_get_all_non_deleted(self):
     """Ensure we get only non-deleted aggregates."""
     ctxt = context.get_admin_context()
     add_counter = 5
     remove_counter = 2
     aggregates = []
     for c in xrange(1, add_counter):
         values = {"name": "fake_aggregate_%d" % c, "availability_zone": "fake_avail_zone"}
         aggregates.append(_create_aggregate(context=ctxt, values=values, metadata=None))
     for c in xrange(1, remove_counter):
         db.aggregate_delete(ctxt, aggregates[c - 1].id)
     results = db.aggregate_get_all(ctxt)
     self.assertEqual(len(results), add_counter - remove_counter)

 def get_all(cls, context):
     db_aggregates = db.aggregate_get_all(context)
     return base.obj_make_list(context, cls(context), objects.Aggregate, db_aggregates)

 def get_all(cls, context):
     db_aggregates = db.aggregate_get_all(context)
     return base.obj_make_list(context, AggregateList(), Aggregate,
                               db_aggregates)

 def get_all(cls, context):
     api_db_aggregates = [cls._fill_deprecated(agg) for agg in
                             _get_all_from_db(context)]
     db_aggregates = db.aggregate_get_all(context)
     return base.obj_make_list(context, cls(context), objects.Aggregate,
                               db_aggregates + api_db_aggregates)