storage/aaStorageTest.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim:set ts=2 sw=2 sts=2 et cindent tw=79 ft=cpp: */
   3 /*
   4  * Copyright (C) 2007 Sergey Yanovich <ynvich@gmail.com>
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License as
   8  * published by the Free Software Foundation; either version 2 of the
   9  * License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public
  17  * License along with this program; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  */
  21
  22 #include <abstract/aacore.h>
  23
  24 #include "nsCOMPtr.h"
  25 #include "nsEmbedString.h"
  26 #include "nsIGenericFactory.h"
  27 #include "nsComponentManagerUtils.h"
  28 #include "nsIMutableArray.h"
  29 #include "nsCOMArray.h"
  30 #include "nsArrayUtils.h"
  31
  32 /* Unfrozen API */
  33 #include "unstable/nsIStringEnumerator.h"
  34 #include "unstable/nsAutoPtr.h"
  35 #include <abstract/cxxunit/nsTestUtils.h>
  36 #include <abstract/cxxunit/nsITest.h>
  37 #include <abstract/cxxunit/nsITestRunner.h>
  38 #include <unstable/mozIStorageConnection.h>
  39
  40 /* Project includes */
  41 #include <abstract/base/aaIEntity.h>
  42 #include <abstract/base/aaIResource.h>
  43 #include <abstract/base/aaIFlow.h>
  44 #include <abstract/base/aaIFact.h>
  45 #include <abstract/base/aaIState.h>
  46 #include <abstract/base/aaIEvent.h>
  47 #include <abstract/base/aaIHandler.h>
  48 #include <abstract/storage/aaISession.h>
  49 #include <abstract/storage/aaISaveQuery.h>
  50 #include <abstract/storage/aaILoadQuery.h>
  51 #include <abstract/storage/aaIFilter.h>
  52 #include "aaSession.h"
  53 #include <abstract/storage/aaBaseLoaders.h>
  54 #include "aaSaveDispatcher.h"
  55 #include "aaFilter.h"
  56 #include "aaSaveEntity.h"
  57 #include "aaLoadEntity.h"
  58 #include "aaSaveResource.h"
  59 #include "aaLoadResource.h"
  60 #include "aaSaveFlow.h"
  61 #include "aaLoadFlow.h"
  62 #include "aaSaveEvent.h"
  63 #include "aaLoadFlowStates.h"
  64 #include <abstract/storage/aaTestConsts.h>
  65
  66 #define AA_STORAGE_TEST_CID \
  67 {0x1e7c924e, 0x872d, 0x4c4e, {0xb8, 0x1c, 0x58, 0xd9, 0x66, 0x4a, 0xe9, 0xd1}}
  68 #define AA_STORAGE_TEST_CONTRACT_ID "@aasii.org/storage/unit;1"
  69
  70 PRBool testState(nsITestRunner *cxxUnitTestRunner, aaIFact *node,
  71     PRInt64 flowId, PRInt64 resourceId, double sum);
  72
  73 class aaStorageTest: public nsITest,
  74                      public nsIUTF8StringEnumerator
  75 {
  76 public:
  77   aaStorageTest():mSubtest(0) {;}
  78   virtual ~aaStorageTest() {;}
  79   NS_DECL_ISUPPORTS
  80   NS_DECL_NSITEST
  81   NS_DECL_NSIUTF8STRINGENUMERATOR
  82 private:
  83   PRUint32 mSubtest;
  84   nsCOMPtr<aaISession> mSession;
  85   nsCOMPtr<aaILoadQuery> mEntitySet;
  86   nsCOMPtr<aaILoadQuery> mResourceSet;
  87   nsCOMPtr<aaILoadQuery> mFlowSet;
  88
  89   nsresult testSession(nsITestRunner *aTestRunner);
  90   nsresult testSaveDispatcher(nsITestRunner *aTestRunner);
  91   nsresult testFilter(nsITestRunner *aTestRunner);
  92   nsresult testSaveEntity(nsITestRunner *aTestRunner);
  93   nsresult testLoadEntity(nsITestRunner *aTestRunner);
  94   nsresult testSaveResource(nsITestRunner *aTestRunner);
  95   nsresult testLoadResource(nsITestRunner *aTestRunner);
  96   nsresult testSaveFlow(nsITestRunner *aTestRunner);
  97   nsresult testLoadFlow(nsITestRunner *aTestRunner);
  98   nsresult testSaveEvent(nsITestRunner *aTestRunner);
  99   nsresult testLoadFlowStates(nsITestRunner *aTestRunner);
 100   nsresult testUpdateEvent(nsITestRunner *aTestRunner);
 101   nsresult testReplaceEvent(nsITestRunner *aTestRunner);
 102   nsresult testDeleteEvent(nsITestRunner *aTestRunner);
 103   nsresult testStopEvent(nsITestRunner *aTestRunner);
 104   nsresult testJunkEvent(nsITestRunner *aTestRunner);
 105 };
 106
 107 NS_IMPL_ISUPPORTS2(aaStorageTest,
 108                    nsITest,
 109                    nsIUTF8StringEnumerator);
 110
 111 /* nsITest */
 112 NS_IMETHODIMP
 113 aaStorageTest::Test(nsITestRunner *aTestRunner)
 114 {
 115   testSession(aTestRunner);
 116   testSaveDispatcher(aTestRunner);
 117   testFilter(aTestRunner);
 118   testSaveEntity(aTestRunner);
 119   testLoadEntity(aTestRunner);
 120   testSaveResource(aTestRunner);
 121   testLoadResource(aTestRunner);
 122   testSaveFlow(aTestRunner);
 123   testLoadFlow(aTestRunner);
 124   testSaveEvent(aTestRunner);
 125   testLoadFlowStates(aTestRunner);
 126   testUpdateEvent(aTestRunner);
 127   testReplaceEvent(aTestRunner);
 128   testDeleteEvent(aTestRunner);
 129   testStopEvent(aTestRunner);
 130   testJunkEvent(aTestRunner);
 131   return NS_OK;
 132 }
 133
 134
 135 /* nsIUTF8tringEnumerator */
 136 static const char* subtests[] =
 137 {
 138   "@aasii.org/storage/unit-account;1"
 139 };
 140 #define subtestCount (sizeof(subtests) / sizeof(char*))
 141
 142 NS_IMETHODIMP
 143 aaStorageTest::HasMore(PRBool *aHasMore)
 144 {
 145   NS_ENSURE_ARG_POINTER(aHasMore);
 146   *aHasMore = (mSubtest < subtestCount);
 147   return NS_OK;
 148 }
 149
 150 NS_IMETHODIMP
 151 aaStorageTest::GetNext(nsACString &aContractID)
 152 {
 153   NS_ENSURE_TRUE(mSubtest < subtestCount, NS_ERROR_FAILURE);
 154   aContractID.Assign( subtests[mSubtest++] );
 155   return NS_OK;
 156 }
 157
 158 /* Private methods */
 159 nsresult
 160 aaStorageTest::testSession(nsITestRunner *aTestRunner)
 161 {
 162   NS_TEST_BEGIN(aTestRunner);
 163   mSession = do_CreateInstance(AA_SESSION_CONTRACT_ID);
 164   NS_TEST_ASSERT_MSG(mSession, "aaSession instance creation" );
 165
 166   aaSession *session = static_cast<aaSession *>(mSession.get());
 167   NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
 168
 169   NS_TEST_ASSERT_MSG( session->mConnection, "session.connection failed" );
 170
 171   return NS_OK;
 172 }
 173
 174 nsresult
 175 aaStorageTest::testSaveDispatcher(nsITestRunner *aTestRunner)
 176 {
 177   NS_TEST_BEGIN(aTestRunner);
 178   nsresult rv;
 179
 180   nsCOMPtr<aaIHandler> saver(do_CreateInstance(
 181         AA_SAVEDISPATCHER_CONTRACT_ID, mSession, &rv));
 182   NS_TEST_ASSERT_MSG(saver, "'saveDispatcher' instance creation" );
 183   NS_ENSURE_SUCCESS(rv, rv);
 184
 185   return NS_OK;
 186 }
 187
 188 nsresult
 189 aaStorageTest::testFilter(nsITestRunner *aTestRunner)
 190 {
 191   NS_TEST_BEGIN(aTestRunner);
 192   nsresult rv;
 193
 194   nsCOMPtr<aaIFilter> filter(do_CreateInstance(
 195         AA_FILTER_CONTRACT_ID, &rv));
 196   NS_TEST_ASSERT_MSG(filter, "[filter] instance creation" );
 197   NS_ENSURE_SUCCESS(rv, rv);
 198
 199   return NS_OK;
 200 }
 201
 202 nsresult
 203 aaStorageTest::testSaveEntity(nsITestRunner *aTestRunner)
 204 {
 205   NS_TEST_BEGIN(aTestRunner);
 206   nsresult rv;
 207
 208   aaSession *session = static_cast<aaSession *>(mSession.get());
 209   NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
 210
 211   nsCOMPtr<aaISaveQuery> saver(do_CreateInstance(
 212         AA_SAVEENTITY_CONTRACT_ID, session->mConnection, &rv));
 213   NS_TEST_ASSERT_MSG(saver, "'saveEntity' instance creation" );
 214   NS_ENSURE_SUCCESS(rv, rv);
 215
 216   nsCOMPtr<aaIEntity> node(do_CreateInstance("@aasii.org/base/entity;1"));
 217   NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
 218
 219   node->SetTag(NS_LITERAL_STRING(AA_ENTITY_TAG_1));
 220   rv = saver->Save(node, nsnull);
 221   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'saveEntity' insertion" );
 222
 223   node->SetTag(NS_LITERAL_STRING(AA_ENTITY_TAG_2));
 224   rv = saver->Save(node, nsnull);
 225   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'saveEntity' second insertion" );
 226
 227   node->SetTag(NS_LITERAL_STRING(AA_ENTITY_TAG_3));
 228   rv = saver->Save(node, nsnull);
 229   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'saveEntity' third insertion" );
 230
 231   node->SetTag(NS_LITERAL_STRING(AA_ENTITY_TAG_4));
 232   rv = saver->Save(node, nsnull);
 233   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'saveEntity' forth insertion" );
 234
 235   return NS_OK;
 236 }
 237
 238 nsresult
 239 aaStorageTest::testLoadEntity(nsITestRunner *aTestRunner)
 240 {
 241   NS_TEST_BEGIN(aTestRunner);
 242   nsresult rv;
 243
 244   aaSession *session = static_cast<aaSession *>(mSession.get());
 245   NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
 246
 247   nsCOMPtr<aaILoadQuery> loader(do_CreateInstance(
 248         AA_LOADENTITY_CONTRACT_ID, session->mConnection, &rv));
 249   NS_TEST_ASSERT_MSG(loader, "'loadEntity' instance creation" );
 250   NS_ENSURE_SUCCESS(rv, rv);
 251
 252   rv = loader->Load();
 253   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'loadEntity' load" );
 254   mEntitySet = loader;
 255
 256   PRUint32 count;
 257   mEntitySet->GetLength(&count);
 258   NS_TEST_ASSERT_MSG(count == 4, "'loadEntity' flow count is wrong");
 259
 260   nsCOMPtr<aaIEntity> node(do_QueryElementAt(mEntitySet, 0, &rv));
 261   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'loadEntity' first item read" );
 262
 263   nsEmbedString tag;
 264   node->GetTag(tag);
 265   NS_TEST_ASSERT_MSG(tag.Equals(NS_ConvertUTF8toUTF16(AA_ENTITY_TAG_1)),
 266         "'loadEntity' first item read differ from inserted" );
 267
 268   PRInt64 id;
 269   node->GetId(&id);
 270   NS_TEST_ASSERT_MSG(id == 1, "'loadEntity' wrong first item id");
 271
 272   return NS_OK;
 273 }
 274
 275 nsresult
 276 aaStorageTest::testSaveResource(nsITestRunner *aTestRunner)
 277 {
 278   NS_TEST_BEGIN(aTestRunner);
 279   nsresult rv;
 280
 281   aaSession *session = static_cast<aaSession *>(mSession.get());
 282   NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
 283
 284   nsCOMPtr<aaISaveQuery> saver(do_CreateInstance(
 285         AA_SAVERESOURCE_CONTRACT_ID, session->mConnection, &rv));
 286   NS_TEST_ASSERT_MSG(saver, "'saveResource' instance creation" );
 287   NS_ENSURE_SUCCESS(rv, rv);
 288
 289   nsCOMPtr<aaIResource> node(do_CreateInstance("@aasii.org/base/resource;1"));
 290   NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
 291
 292   node->SetTag(NS_LITERAL_STRING(AA_RESOURCE_TAG_1));
 293   rv = saver->Save(node, nsnull);
 294   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'saveResource' insertion" );
 295
 296   node->SetTag(NS_LITERAL_STRING(AA_RESOURCE_TAG_2));
 297   rv = saver->Save(node, nsnull);
 298   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'saveResource' second insertion" );
 299
 300   return NS_OK;
 301 }
 302
 303 nsresult
 304 aaStorageTest::testLoadResource(nsITestRunner *aTestRunner)
 305 {
 306   NS_TEST_BEGIN(aTestRunner);
 307   nsresult rv;
 308
 309   aaSession *session = static_cast<aaSession *>(mSession.get());
 310   NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
 311
 312   nsCOMPtr<aaILoadQuery> loader(do_CreateInstance(
 313         AA_LOADRESOURCE_CONTRACT_ID, session->mConnection, &rv));
 314   NS_TEST_ASSERT_MSG(loader, "'loadResource' instance creation" );
 315   NS_ENSURE_SUCCESS(rv, rv);
 316
 317   rv = loader->Load();
 318   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'loadResource' load" );
 319   mResourceSet = loader;
 320
 321   nsCOMPtr<aaIResource> node(do_QueryElementAt(mResourceSet, 0, &rv));
 322   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'loadResource' first item not read" );
 323
 324   nsEmbedString tag;
 325   node->GetTag(tag);
 326   NS_TEST_ASSERT_MSG(tag.Equals(NS_ConvertUTF8toUTF16(AA_RESOURCE_TAG_1)),
 327         "'loadResource' first item read differs from inserted" );
 328
 329   return NS_OK;
 330 }
 331
 332 nsresult
 333 aaStorageTest::testSaveFlow(nsITestRunner *aTestRunner)
 334 {
 335   NS_TEST_BEGIN(aTestRunner);
 336   nsresult rv;
 337
 338   aaSession *session = static_cast<aaSession *>(mSession.get());
 339   NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
 340
 341   nsCOMPtr<aaISaveQuery> saver(do_CreateInstance(
 342         AA_SAVEFLOW_CONTRACT_ID, session->mConnection, &rv));
 343   NS_TEST_ASSERT_MSG(saver, "'saveflow' instance creation" );
 344   NS_ENSURE_SUCCESS(rv, rv);
 345
 346   nsCOMPtr<aaIFlow> node(do_CreateInstance("@aasii.org/base/flow;1"));
 347   NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
 348
 349   nsCOMPtr<aaIResource> share(do_QueryElementAt(mResourceSet,1));
 350   nsCOMPtr<aaIResource> rub(do_QueryElementAt(mResourceSet,0));
 351
 352   nsCOMPtr<aaIEntity> entity(do_QueryElementAt(mEntitySet, 1));
 353   node->SetEntity(entity);
 354   node->SetTag(NS_LITERAL_STRING(AA_FLOW_TAG_1));
 355   node->SetGiveResource(share);
 356   node->SetTakeResource(rub);
 357   node->SetRate(AA_FLOW_SHARE_RATE);
 358   node->SetLimit(AA_EVENT_AMOUNT_1 / AA_FLOW_SHARE_RATE);
 359   rv = saver->Save(node, nsnull);
 360   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'saveFlow' 1st insertion" );
 361
 362   entity = do_QueryElementAt(mEntitySet, 2);
 363   node->SetEntity(entity);
 364   node->SetTag(NS_LITERAL_STRING(AA_FLOW_TAG_3));
 365   node->SetGiveResource(share);
 366   node->SetTakeResource(rub);
 367   node->SetRate(AA_FLOW_SHARE_RATE);
 368   node->SetLimit(AA_EVENT_AMOUNT_2 / AA_FLOW_SHARE_RATE);
 369   rv = saver->Save(node, nsnull);
 370   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'saveFlow' 2nd insertion" );
 371
 372   entity = do_QueryElementAt(mEntitySet, 3);
 373   node->SetEntity(entity);
 374   node->SetTag(NS_LITERAL_STRING(AA_FLOW_TAG_5));
 375   node->SetGiveResource(rub);
 376   node->SetTakeResource(rub);
 377   node->SetRate(1.0);
 378   node->SetLimit(0.0);
 379   rv = saver->Save(node, nsnull);
 380   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'saveFlow' 3rd insertion" );
 381
 382   return NS_OK;
 383 }
 384
 385 nsresult
 386 aaStorageTest::testLoadFlow(nsITestRunner *aTestRunner)
 387 {
 388   NS_TEST_BEGIN(aTestRunner);
 389   nsresult rv;
 390
 391   aaSession *session = static_cast<aaSession *>(mSession.get());
 392   NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
 393
 394   mFlowSet = do_CreateInstance(AA_LOADFLOW_CONTRACT_ID, session->mConnection,
 395       &rv);
 396   NS_TEST_ASSERT_MSG(mFlowSet, "'loadFlow' instance creation" );
 397   NS_ENSURE_SUCCESS(rv, rv);
 398
 399   rv = mFlowSet->Load();
 400   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'loadFlow' load" );
 401
 402   nsCOMPtr<aaIFlow> node(do_QueryElementAt(mFlowSet, 0, &rv));
 403   NS_TEST_ASSERT_MSG(node, "'loadFlow' first item not read" );
 404   NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
 405
 406   nsEmbedString tag;
 407   node->GetTag(tag);
 408   NS_TEST_ASSERT_MSG(tag.Equals(NS_ConvertUTF8toUTF16(AA_FLOW_TAG_1)),
 409         "'loadFlow' first item read differs from inserted" );
 410
 411   nsCOMPtr<aaIEntity> entity;
 412   rv = node->GetEntity(getter_AddRefs( entity ));
 413   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'loadFlow' flow.entity read" );
 414   NS_TEST_ASSERT_MSG(entity, "'loadFlow' flow.entity read is null" );
 415   if (entity) {
 416     entity->GetTag(tag);
 417     NS_TEST_ASSERT_MSG(tag.Equals(NS_ConvertUTF8toUTF16(AA_ENTITY_TAG_2)),
 418         "'loadFlow' flow.entity differs from inserted" );
 419   }
 420
 421   nsCOMPtr<aaIResource> res;
 422   rv = node->GetGiveResource(getter_AddRefs( res ));
 423   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv),
 424       "'loadFlow' flow.giveResource not read" );
 425   NS_TEST_ASSERT_MSG(res, "'loadFlow' flow.giveResource read is null" );
 426   if (res) {
 427     res->GetTag(tag);
 428     NS_TEST_ASSERT_MSG(tag.Equals(NS_ConvertUTF8toUTF16(AA_RESOURCE_TAG_2)),
 429         "'loadFlow' flow.giveResource differs from inserted" );
 430   }
 431
 432   rv = node->GetTakeResource(getter_AddRefs( res ));
 433   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv),
 434       "'loadFlow' flow.takeResource not read" );
 435   NS_TEST_ASSERT_MSG(res, "'loadFlow' flow.takeResource read is null" );
 436   if (res) {
 437     res->GetTag(tag);
 438     NS_TEST_ASSERT_MSG(tag.Equals(NS_ConvertUTF8toUTF16(AA_RESOURCE_TAG_1)),
 439         "'loadFlow' flow.takeResource differs from inserted" );
 440   }
 441
 442   double rate;
 443   rv = node->GetRate( &rate );
 444   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'loadFlow' flow.rate not read" );
 445   NS_TEST_ASSERT_MSG(rate == AA_FLOW_SHARE_RATE,
 446         "'loadFlow' flow.rate differs from inserted" );
 447
 448   return NS_OK;
 449 }
 450
 451 nsresult
 452 aaStorageTest::testSaveEvent(nsITestRunner *aTestRunner)
 453 {
 454   NS_TEST_BEGIN(aTestRunner);
 455   nsresult rv;
 456
 457   aaSession *session = static_cast<aaSession *>(mSession.get());
 458   NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
 459
 460   nsCOMPtr<aaISaveQuery> saver(do_CreateInstance(
 461         AA_SAVEEVENT_CONTRACT_ID, session->mConnection, &rv));
 462   NS_TEST_ASSERT_MSG(saver, "'saveEvent' instance creation" );
 463
 464   nsCOMPtr<aaIEvent> node(do_CreateInstance("@aasii.org/base/event;1"));
 465   /* Set time to 2007-08-29 */
 466   PRExplodedTime tm = {0,0,0,12,29,7,2007};
 467   node->SetTime(PR_ImplodeTime(&tm));
 468
 469   nsCOMPtr<nsIMutableArray> block(do_QueryInterface( node ));
 470   NS_ENSURE_TRUE(block, NS_ERROR_UNEXPECTED);
 471
 472   /* Fact 1 */
 473   nsCOMPtr<aaIFact> fact(do_CreateInstance("@aasii.org/base/fact;1"));
 474   fact->SetAmount(AA_EVENT_AMOUNT_2);
 475   nsCOMPtr<aaIFlow> flow(do_QueryElementAt(mFlowSet,1));
 476   fact->SetTakeFrom(flow);
 477   flow = do_QueryElementAt(mFlowSet,2);
 478   fact->SetGiveTo(flow);
 479
 480   rv = block->AppendElement(fact, PR_FALSE);
 481   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[insert event] appendElement" );
 482
 483   rv = saver->Save(node, nsnull);
 484   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[insert event] saving" );
 485
 486   return NS_OK;
 487 }
 488
 489 PRBool
 490 testState(nsITestRunner *cxxUnitTestRunner, aaIState *node, PRInt64 flowId,
 491     PRInt64 resourceId, double sum)
 492 {
 493   NS_TEST_ASSERT_MSG(node, " 'state' is null");
 494   nsresult rv;
 495   PRBool equals = PR_TRUE;
 496   nsCOMPtr<aaIFlow> flow;
 497   rv = node->GetFlow(getter_AddRefs( flow ));
 498   NS_TEST_ASSERT_MSG(flow, " 'state.flow' is null");
 499   PRInt64 id;
 500   nsEmbedString tag;
 501   if (NS_LIKELY( flow )) {
 502     flow->GetId(&id);
 503     if (NS_UNLIKELY( id != flowId) ) {
 504       equals = PR_FALSE;
 505       NS_TEST_ASSERT_MSG(PR_FALSE, " 'state.flow.id' is wrong");
 506     }
 507   } else {
 508     equals = PR_FALSE;
 509   }
 510
 511   nsCOMPtr<aaIResource> resource;
 512   rv = node->GetResource(getter_AddRefs( resource ));
 513   NS_TEST_ASSERT_MSG(resource, " 'state.resource' is null" );
 514   if (NS_LIKELY( resource )) {
 515     resource->GetId(&id);
 516     if (NS_UNLIKELY( id != resourceId) ) {
 517       equals = PR_FALSE;
 518       NS_TEST_ASSERT_MSG(PR_FALSE, " 'state.resource.id' is wrong");
 519     }
 520   } else {
 521     equals = PR_FALSE;
 522   }
 523
 524   double amount, diff;
 525   rv = node->GetAmount(&amount);
 526   diff = amount - sum;
 527   if (! isZero(diff)) {
 528     equals = PR_FALSE;
 529     NS_TEST_ASSERT_MSG(PR_FALSE, " 'state.amount' is wrong");
 530   }
 531
 532   return equals;
 533 }
 534
 535 nsresult
 536 aaStorageTest::testLoadFlowStates(nsITestRunner *aTestRunner)
 537 {
 538   NS_TEST_BEGIN(aTestRunner);
 539   nsresult rv;
 540
 541   aaSession *session = static_cast<aaSession *>(mSession.get());
 542   NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
 543
 544   session->mConnection = nsnull;
 545   session->getDatabase();
 546   nsCOMPtr<aaILoadQuery> set(do_CreateInstance(
 547         AA_LOADFLOWSTATES_CONTRACT_ID, session->mConnection, &rv));
 548   NS_TEST_ASSERT_MSG(set, "[load states] instance creation" );
 549   NS_ENSURE_SUCCESS(rv, rv);
 550
 551   rv = set->Load();
 552   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[load states] loading" );
 553   NS_ENSURE_TRUE(set, NS_ERROR_FAILURE);
 554
 555   PRUint32 count;
 556   set->GetLength(&count);
 557   NS_TEST_ASSERT_MSG(count == 2, "[load states] wrong flow count");
 558
 559   nsCOMPtr<aaIState> node(do_QueryElementAt(set, 0, &rv));
 560   NS_TEST_ASSERT_MSG(node, "[load states 1st item not read" );
 561   NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
 562
 563   NS_TEST_ASSERT_MSG(testState(aTestRunner, node, 2, 2, AA_EVENT_AMOUNT_2
 564         / AA_FLOW_SHARE_RATE), "[load states] flow2 is wrong");
 565
 566   nsCOMPtr<aaIFlow> flow;
 567   nsEmbedString tag;
 568   node->GetFlow(getter_AddRefs( flow ));
 569   if (flow) {
 570     flow->GetTag(tag);
 571     NS_TEST_ASSERT_MSG( tag.Equals(NS_ConvertUTF8toUTF16(AA_FLOW_TAG_3)),
 572       "[load states] 'fact.flow.tag' is wrong" );
 573   }
 574
 575   nsCOMPtr<aaIResource> resource;
 576   node->GetResource(getter_AddRefs( resource ));
 577   if (resource) {
 578     resource->GetTag(tag);
 579     NS_TEST_ASSERT_MSG( tag.Equals(NS_ConvertUTF8toUTF16(AA_RESOURCE_TAG_2)),
 580         "[load states] 'state.resource.tag' is wrong" );
 581   }
 582
 583   node = do_QueryElementAt(set, 1, &rv);
 584   NS_TEST_ASSERT_MSG(node, "[load states] 2nd item not read" );
 585   NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
 586
 587   NS_TEST_ASSERT_MSG(testState(aTestRunner, node, 3, 1, AA_EVENT_AMOUNT_2),
 588       "[load states] flow3 is wrong");
 589
 590   return NS_OK;
 591 }
 592
 593 nsresult
 594 aaStorageTest::testUpdateEvent(nsITestRunner *aTestRunner)
 595 {
 596   NS_TEST_BEGIN(aTestRunner);
 597   nsresult rv;
 598
 599   aaSession *session = static_cast<aaSession *>(mSession.get());
 600   NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
 601
 602   nsCOMPtr<aaISaveQuery> saver(do_CreateInstance(
 603         AA_SAVEEVENT_CONTRACT_ID, session->mConnection, &rv));
 604   NS_TEST_ASSERT_MSG(saver, "'saveEvent' instance creation" );
 605   NS_ENSURE_TRUE(saver, NS_ERROR_UNEXPECTED);
 606
 607   nsCOMPtr<aaIEvent> node(do_CreateInstance("@aasii.org/base/event;1"));
 608   /* Set time to 2007-08-29 */
 609   PRExplodedTime tm = {0,0,0,12,29,7,2007};
 610   node->SetTime(PR_ImplodeTime(&tm));
 611
 612   nsCOMPtr<nsIMutableArray> block(do_QueryInterface( node ));
 613   NS_ENSURE_TRUE(block, NS_ERROR_UNEXPECTED);
 614
 615   /* Fact 2 */
 616   nsCOMPtr<aaIFact> fact(do_CreateInstance("@aasii.org/base/fact;1"));
 617   fact->SetAmount(AA_EVENT_AMOUNT_3);
 618   nsCOMPtr<aaIFlow> flow(do_QueryElementAt(mFlowSet,0));
 619   fact->SetTakeFrom(flow);
 620   flow = do_QueryElementAt(mFlowSet,2);
 621   fact->SetGiveTo(flow);
 622
 623   rv = block->AppendElement(fact, PR_FALSE);
 624   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[update event] appending element" );
 625
 626   rv = saver->Save(node, nsnull);
 627   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[update event] saving" );
 628
 629   nsCOMPtr<aaILoadQuery> set(do_CreateInstance(
 630         AA_LOADFLOWSTATES_CONTRACT_ID, session->mConnection, &rv));
 631   NS_TEST_ASSERT_MSG(set, "[update event] creating loader" );
 632   NS_ENSURE_SUCCESS(rv, rv);
 633
 634   rv = set->Load();
 635   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[update event] loading states" );
 636
 637   PRUint32 count;
 638   set->GetLength(&count);
 639   NS_TEST_ASSERT_MSG(count == 3, "[update event] wrong flow count");
 640
 641   nsCOMPtr<aaIState> state;
 642   state = do_QueryElementAt(set, 2, &rv);
 643   NS_TEST_ASSERT_MSG(state, "[update event] 3rd item not read" );
 644   NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
 645
 646   NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 1, 2, AA_EVENT_AMOUNT_3
 647         / AA_FLOW_SHARE_RATE), "[update event] flow1 is wrong");
 648
 649   state = do_QueryElementAt(set, 1, &rv);
 650   NS_TEST_ASSERT_MSG(state, "[update event] 2nd item not read" );
 651   NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
 652
 653   NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 3, 1, AA_EVENT_AMOUNT_2
 654         + AA_EVENT_AMOUNT_3), "[update event] flow3 is wrong");
 655   return NS_OK;
 656 }
 657
 658 nsresult
 659 aaStorageTest::testReplaceEvent(nsITestRunner *aTestRunner)
 660 {
 661   NS_TEST_BEGIN(aTestRunner);
 662   nsresult rv;
 663
 664   aaSession *session = static_cast<aaSession *>(mSession.get());
 665   NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
 666
 667   nsCOMPtr<aaIResource> vaio(do_CreateInstance("@aasii.org/base/resource;1"));
 668   NS_ENSURE_TRUE(vaio, NS_ERROR_FAILURE);
 669   vaio->SetTag(NS_LITERAL_STRING(AA_RESOURCE_TAG_3));
 670   session->Save(vaio, nsnull);
 671
 672   PRInt64 id;
 673   vaio->GetId( &id );
 674   NS_TEST_ASSERT_MSG(id == 3, "[replace event] unexpected 'resource.id'");
 675   NS_ENSURE_TRUE(id == 3, NS_ERROR_UNEXPECTED);
 676
 677   nsCOMPtr<aaIEntity> shop(do_CreateInstance("@aasii.org/base/entity;1"));
 678   NS_ENSURE_TRUE(shop, NS_ERROR_FAILURE);
 679   shop->SetTag(NS_LITERAL_STRING(AA_ENTITY_TAG_5));
 680   session->Save(shop, nsnull);
 681
 682   shop->GetId( &id );
 683   NS_TEST_ASSERT_MSG(id == 5, "[replace event] unexpected 'entity.id'");
 684   NS_ENSURE_TRUE(id == 5, NS_ERROR_UNEXPECTED);
 685
 686   nsCOMPtr<aaIResource> rub(do_QueryElementAt(mResourceSet,0));
 687
 688   nsCOMPtr<aaIFlow> purchase(do_CreateInstance("@aasii.org/base/flow;1"));
 689   NS_ENSURE_TRUE(purchase, NS_ERROR_FAILURE);
 690   purchase->SetTag(NS_LITERAL_STRING(AA_FLOW_TAG_6));
 691   purchase->SetEntity(shop);
 692   purchase->SetGiveResource(rub);
 693   purchase->SetTakeResource(vaio);
 694   purchase->SetRate(1.0 / AA_EVENT_AMOUNT_4);
 695   purchase->SetLimit(AA_EVENT_AMOUNT_5);
 696   rv = session->Save(purchase, nsnull);
 697   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[replace event] saving flow");
 698   NS_ENSURE_SUCCESS(rv, rv);
 699
 700   purchase->GetId( &id );
 701   NS_TEST_ASSERT_MSG(id == 4, "[replace event] unexpected 'flow.id'");
 702   NS_ENSURE_TRUE(id == 4, NS_ERROR_UNEXPECTED);
 703
 704   nsCOMPtr<aaIEvent> node(do_CreateInstance("@aasii.org/base/event;1"));
 705   /* Set time to 2007-08-30 */
 706   PRExplodedTime tm = {0,0,0,12,30,7,2007};
 707   node->SetTime(PR_ImplodeTime(&tm));
 708
 709   nsCOMPtr<nsIMutableArray> block(do_QueryInterface( node ));
 710   NS_ENSURE_TRUE(block, NS_ERROR_UNEXPECTED);
 711
 712   /* Fact 3 */
 713   nsCOMPtr<aaIFact> fact(do_CreateInstance("@aasii.org/base/fact;1"));
 714   fact->SetAmount(AA_EVENT_AMOUNT_4);
 715   nsCOMPtr<aaIFlow> flow(do_QueryElementAt(mFlowSet,2));
 716   fact->SetTakeFrom(flow);
 717   fact->SetGiveTo(purchase);
 718
 719   rv = block->AppendElement(fact, PR_FALSE);
 720   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[replace event] appending element" );
 721
 722   rv = session->Save(node, nsnull);
 723   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[replace event] saving" );
 724
 725   nsCOMPtr<aaILoadQuery> set(do_CreateInstance(
 726         AA_LOADFLOWSTATES_CONTRACT_ID, session->mConnection, &rv));
 727   NS_TEST_ASSERT_MSG(set, "[replace event] creating loader" );
 728   NS_ENSURE_SUCCESS(rv, rv);
 729
 730   rv = set->Load();
 731   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[replace event] loading states" );
 732
 733   PRUint32 count;
 734   set->GetLength(&count);
 735   NS_TEST_ASSERT_MSG(count == 4, "[replace event] wrong flow count");
 736
 737   nsCOMPtr<aaIState> state;
 738   state = do_QueryElementAt(set, 2, &rv);
 739   NS_TEST_ASSERT_MSG(state, "[replace event] 2nd item not read" );
 740   NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
 741
 742   NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 3, 1, AA_EVENT_AMOUNT_2
 743         + AA_EVENT_AMOUNT_3 - AA_EVENT_AMOUNT_4),
 744       "[replace event] flow3 is wrong");
 745
 746   state = do_QueryElementAt(set, 3, &rv);
 747   NS_TEST_ASSERT_MSG(state, "[replace event] 4th item not read" );
 748   NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
 749
 750   NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 4, 3, AA_EVENT_AMOUNT_5),
 751       "[replace event] flow4 is wrong");
 752   return NS_OK;
 753 }
 754
 755 nsresult
 756 aaStorageTest::testDeleteEvent(nsITestRunner *aTestRunner)
 757 {
 758   NS_TEST_BEGIN(aTestRunner);
 759   nsresult rv;
 760
 761   rv = mResourceSet->Load();
 762   NS_TEST_ASSERT_OK(rv);
 763
 764   nsCOMPtr<aaIResource> rub(do_QueryElementAt(mResourceSet, 0, &rv));
 765   NS_ENSURE_TRUE(rub, rv);
 766
 767   PRInt64 id;
 768   rub->GetId( &id );
 769   NS_TEST_ASSERT_MSG(id == 1, "[delete event] unexpected 'resource.id'");
 770   NS_ENSURE_TRUE(id == 1, NS_ERROR_UNEXPECTED);
 771
 772   nsCOMPtr<aaIResource> eur(do_CreateInstance("@aasii.org/base/resource;1"));
 773   NS_ENSURE_TRUE(eur, NS_ERROR_FAILURE);
 774   eur->SetTag(NS_LITERAL_STRING(AA_RESOURCE_TAG_4));
 775   mSession->Save(eur, nsnull);
 776
 777   eur->GetId( &id );
 778   NS_TEST_ASSERT_MSG(id == 4, "[delete event] unexpected 'resource.id'");
 779   NS_ENSURE_TRUE(id == 4, NS_ERROR_UNEXPECTED);
 780
 781   rv = mEntitySet->Load();
 782   NS_TEST_ASSERT_OK(rv);
 783
 784   nsCOMPtr<aaIEntity> bank(do_QueryElementAt(mEntitySet, 3, &rv));
 785   NS_ENSURE_TRUE(bank, rv);
 786
 787   bank->GetId( &id );
 788   NS_TEST_ASSERT_MSG(id == 4, "[delete event] unexpected 'entity.id'");
 789   NS_ENSURE_TRUE(id == 4, NS_ERROR_UNEXPECTED);
 790
 791   rv = mFlowSet->Load();
 792   NS_TEST_ASSERT_OK(rv);
 793
 794   nsCOMPtr<aaIFlow> bankAccRub(do_QueryElementAt(mFlowSet,2));
 795
 796   /* Flow for a forex deal */
 797   nsCOMPtr<aaIFlow> forex(do_CreateInstance("@aasii.org/base/flow;1"));
 798   NS_ENSURE_TRUE(forex, NS_ERROR_FAILURE);
 799   forex->SetTag(NS_LITERAL_STRING(AA_FLOW_TAG_7));
 800   forex->SetEntity(bank);
 801   forex->SetGiveResource(rub);
 802   forex->SetTakeResource(eur);
 803   forex->SetRate(1 / AA_EVENT_RATE_2);
 804   forex->SetLimit(AA_EVENT_AMOUNT_6 * AA_EVENT_RATE_2);
 805   rv = mSession->Save(forex, nsnull);
 806   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[delete event] saving flow");
 807   NS_ENSURE_SUCCESS(rv, rv);
 808
 809   forex->GetId( &id );
 810   NS_TEST_ASSERT_MSG(id == 5, "[delete event] unexpected 'flow.id'");
 811   NS_ENSURE_TRUE(id == 5, NS_ERROR_UNEXPECTED);
 812
 813   /* Flow for EUR in the bank */
 814   nsCOMPtr<aaIFlow> bankAccEur(do_CreateInstance("@aasii.org/base/flow;1"));
 815   NS_ENSURE_TRUE(bankAccEur, NS_ERROR_FAILURE);
 816   bankAccEur->SetTag(NS_LITERAL_STRING(AA_FLOW_TAG_8));
 817   bankAccEur->SetEntity(bank);
 818   bankAccEur->SetGiveResource(eur);
 819   bankAccEur->SetTakeResource(eur);
 820   bankAccEur->SetRate(1);
 821   bankAccEur->SetLimit(0.0);
 822   rv = mSession->Save(bankAccEur, nsnull);
 823   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[delete event] saving flow");
 824   NS_ENSURE_SUCCESS(rv, rv);
 825
 826   bankAccEur->GetId( &id );
 827   NS_TEST_ASSERT_MSG(id == 6, "[delete event] unexpected 'flow.id'");
 828   NS_ENSURE_TRUE(id == 6, NS_ERROR_UNEXPECTED);
 829
 830   nsCOMPtr<aaIEvent> node(do_CreateInstance("@aasii.org/base/event;1"));
 831   /* Set time to 2007-08-30 */
 832   PRExplodedTime tm = {0,0,0,12,30,7,2007};
 833   node->SetTime(PR_ImplodeTime(&tm));
 834
 835   nsCOMPtr<nsIMutableArray> block(do_QueryInterface( node ));
 836   NS_ENSURE_TRUE(block, NS_ERROR_UNEXPECTED);
 837
 838   /* Fact 4 */
 839   nsCOMPtr<aaIFact> fact(do_CreateInstance("@aasii.org/base/fact;1"));
 840   fact->SetAmount(AA_EVENT_AMOUNT_6);
 841   fact->SetTakeFrom(forex);
 842   fact->SetGiveTo(bankAccEur);
 843
 844   rv = block->AppendElement(fact, PR_FALSE);
 845   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[delete event] appending element" );
 846
 847   rv = mSession->Save(node, nsnull);
 848   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[delete event] saving [2]" );
 849
 850   nsCOMPtr<aaILoadQuery> set;
 851   mSession->CreateQuery(AA_LOADFLOWSTATES_CONTRACT_ID, getter_AddRefs( set ));
 852   NS_TEST_ASSERT_MSG(set, "[delete event] creating loader" );
 853   NS_ENSURE_SUCCESS(rv, rv);
 854
 855   rv = set->Load();
 856   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[delete event] loading states [2]" );
 857
 858   PRUint32 count;
 859   set->GetLength(&count);
 860   NS_TEST_ASSERT_MSG(count == 6, "[delete event] wrong flow count");
 861
 862   nsCOMPtr<aaIState> state;
 863   state = do_QueryElementAt(set, 2, &rv);
 864   NS_TEST_ASSERT_MSG(state, "[delete event] 2nd item not read" );
 865   NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
 866
 867   NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 3, 1, AA_EVENT_AMOUNT_2
 868         + AA_EVENT_AMOUNT_3 - AA_EVENT_AMOUNT_4),
 869       "[delete event] flow3 is wrong");
 870
 871   state = do_QueryElementAt(set, 4, &rv);
 872   NS_TEST_ASSERT_MSG(state, "[delete event] 4th item not read" );
 873   NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
 874
 875   NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 5, 1, AA_EVENT_AMOUNT_6
 876         * AA_EVENT_RATE_2),
 877       "[delete event] flow5 is wrong");
 878
 879   state = do_QueryElementAt(set, 5, &rv);
 880   NS_TEST_ASSERT_MSG(state, "[delete event] 4th item not read" );
 881   NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
 882
 883   NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 6, 4, AA_EVENT_AMOUNT_6),
 884       "[delete event] flow6 is wrong");
 885   /* Fact 4 is processed correctly */
 886
 887   node = do_CreateInstance("@aasii.org/base/event;1");
 888   /* Set time to 2007-08-30 */
 889   node->SetTime(PR_ImplodeTime(&tm));
 890
 891   block = do_QueryInterface( node );
 892   NS_ENSURE_TRUE(block, NS_ERROR_UNEXPECTED);
 893
 894   /* Fact 5 */
 895   fact = do_CreateInstance("@aasii.org/base/fact;1");
 896   /* Forex deal is paid correctly */
 897   fact->SetAmount(AA_EVENT_AMOUNT_6 * AA_EVENT_RATE_2);
 898   fact->SetTakeFrom(bankAccRub);
 899   fact->SetGiveTo(forex);
 900
 901   rv = block->AppendElement(fact, PR_FALSE);
 902   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[delete event] appending element" );
 903
 904   rv = mSession->Save(node, nsnull);
 905   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[delete event] saving" );
 906
 907   rv = set->Load();
 908   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[delete event] loading states" );
 909
 910   set->GetLength(&count);
 911   NS_TEST_ASSERT_MSG(count == 5, "[delete event] wrong flow count");
 912
 913   state = do_QueryElementAt(set, 2, &rv);
 914   NS_TEST_ASSERT_MSG(state, "[delete event] 2nd item not read" );
 915   NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
 916
 917   NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 3, 1, AA_EVENT_AMOUNT_2
 918         + AA_EVENT_AMOUNT_3 - AA_EVENT_AMOUNT_4
 919         - AA_EVENT_AMOUNT_6 * AA_EVENT_RATE_2),
 920       "[delete event] flow3 is wrong");
 921
 922   state = do_QueryElementAt(set, 4, &rv);
 923   NS_TEST_ASSERT_MSG(state, "[delete event] 4th item not read" );
 924   NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
 925
 926   NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 6, 4, AA_EVENT_AMOUNT_6),
 927       "[delete event] flow6 is wrong");
 928
 929   nsCOMPtr<aaIFilter> filter;
 930   rv = set->GetFilter(getter_AddRefs( filter ));
 931   NS_TEST_ASSERT_OK(rv);
 932   NS_ENSURE_SUCCESS(rv, rv);
 933
 934   nsCOMPtr<aaIStringFilter> strFilter(do_QueryInterface(filter, &rv));
 935   NS_ENSURE_TRUE(strFilter, rv);
 936   strFilter->SetExpression(NS_LITERAL_CSTRING(" WHERE state.id = 6"));
 937
 938   rv = set->SetFilter(filter);
 939   NS_TEST_ASSERT_OK(rv);
 940   NS_ENSURE_SUCCESS(rv, rv);
 941
 942   rv = set->Load();
 943   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[delete event] loading states" );
 944
 945   set->GetLength(&count);
 946   NS_TEST_ASSERT_MSG(count == 0, "[delete event] wrong flow count");
 947   return NS_OK;
 948 }
 949
 950 nsresult
 951 aaStorageTest::testStopEvent(nsITestRunner *aTestRunner)
 952 {
 953   NS_TEST_BEGIN(aTestRunner);
 954   nsresult rv;
 955
 956   rv = mResourceSet->Load();
 957   NS_TEST_ASSERT_OK(rv);
 958
 959   nsCOMPtr<aaIResource> rub(do_QueryElementAt(mResourceSet, 0, &rv));
 960   NS_ENSURE_TRUE(rub, rv);
 961
 962   PRInt64 id;
 963   rub->GetId( &id );
 964   NS_TEST_ASSERT_MSG(id == 1, "[stop event] unexpected 'resource.id'");
 965   NS_ENSURE_TRUE(id == 1, NS_ERROR_UNEXPECTED);
 966
 967   nsCOMPtr<aaIResource> eur(do_QueryElementAt(mResourceSet, 3, &rv));
 968   NS_ENSURE_TRUE(eur, NS_ERROR_FAILURE);
 969
 970   eur->GetId( &id );
 971   NS_TEST_ASSERT_MSG(id == 4, "[stop event] unexpected 'resource.id'");
 972   NS_ENSURE_TRUE(id == 4, NS_ERROR_UNEXPECTED);
 973
 974   rv = mEntitySet->Load();
 975   NS_TEST_ASSERT_OK(rv);
 976
 977   nsCOMPtr<aaIEntity> bank(do_QueryElementAt(mEntitySet, 3, &rv));
 978   NS_ENSURE_TRUE(bank, rv);
 979
 980   bank->GetId( &id );
 981   NS_TEST_ASSERT_MSG(id == 4, "[stop event] unexpected 'entity.id'");
 982   NS_ENSURE_TRUE(id == 4, NS_ERROR_UNEXPECTED);
 983
 984   rv = mFlowSet->Load();
 985   NS_TEST_ASSERT_OK(rv);
 986
 987   nsCOMPtr<aaIFlow> bankAccRub(do_QueryElementAt(mFlowSet,2));
 988   nsCOMPtr<aaIFlow> bankAccEur(do_QueryElementAt(mFlowSet,5));
 989
 990   /* Flow for a forex deal #2*/
 991   nsCOMPtr<aaIFlow> forex(do_CreateInstance("@aasii.org/base/flow;1"));
 992   NS_ENSURE_TRUE(forex, NS_ERROR_FAILURE);
 993   forex->SetTag(NS_LITERAL_STRING(AA_FLOW_TAG_9));
 994   forex->SetEntity(bank);
 995   forex->SetGiveResource(eur);
 996   forex->SetTakeResource(rub);
 997   forex->SetRate(AA_EVENT_RATE_3);
 998   forex->SetLimit(AA_EVENT_AMOUNT_6);
 999   rv = mSession->Save(forex, nsnull);
1000   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[stop event] saving flow");
1001   NS_ENSURE_SUCCESS(rv, rv);
1002
1003   forex->GetId( &id );
1004   NS_TEST_ASSERT_MSG(id == 7, "[stop event] unexpected 'flow.id'");
1005   NS_ENSURE_TRUE(id == 7, NS_ERROR_UNEXPECTED);
1006
1007   nsCOMPtr<aaIEvent> node(do_CreateInstance("@aasii.org/base/event;1"));
1008   /* Set time to 2007-08-31 */
1009   PRExplodedTime tm = {0,0,0,12,31,7,2007};
1010   node->SetTime(PR_ImplodeTime(&tm));
1011
1012   nsCOMPtr<nsIMutableArray> block(do_QueryInterface( node ));
1013   NS_ENSURE_TRUE(block, NS_ERROR_UNEXPECTED);
1014
1015   /* Fact 6 */
1016   nsCOMPtr<aaIFact> fact(do_CreateInstance("@aasii.org/base/fact;1"));
1017   fact->SetAmount(AA_EVENT_AMOUNT_6);
1018   fact->SetTakeFrom(bankAccEur);
1019   fact->SetGiveTo(forex);
1020
1021   rv = block->AppendElement(fact, PR_FALSE);
1022   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[stop event] appending element" );
1023
1024   rv = mSession->Save(node, nsnull);
1025   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[stop event] saving" );
1026
1027   nsCOMPtr<aaILoadQuery> set;
1028   mSession->CreateQuery(AA_LOADFLOWSTATES_CONTRACT_ID, getter_AddRefs( set ));
1029   NS_TEST_ASSERT_MSG(set, "[stop event] creating loader" );
1030   NS_ENSURE_SUCCESS(rv, rv);
1031
1032   rv = set->Load();
1033   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[stop event] loading states" );
1034
1035   PRUint32 count;
1036   set->GetLength(&count);
1037   NS_TEST_ASSERT_MSG(count == 5, "[stop event] wrong flow count");
1038
1039   nsCOMPtr<aaIState> state;
1040   state = do_QueryElementAt(set, 2, &rv);
1041   NS_TEST_ASSERT_MSG(state, "[stop event] 2nd item not read" );
1042   NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
1043
1044   NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 3, 1, AA_EVENT_AMOUNT_2
1045         + AA_EVENT_AMOUNT_3 - AA_EVENT_AMOUNT_4
1046         - AA_EVENT_AMOUNT_6 * AA_EVENT_RATE_2),
1047       "[stop event] flow3 is wrong");
1048
1049   state = do_QueryElementAt(set, 4, &rv);
1050   NS_TEST_ASSERT_MSG(state, "[stop event] 4th item not read" );
1051   NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
1052
1053   NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 7, 1, AA_EVENT_AMOUNT_6
1054         * AA_EVENT_RATE_3),
1055       "[stop event] flow7 is wrong");
1056   /* Forex deal #2 is paid correctly */
1057
1058   nsCOMPtr<aaIFilter> filter;
1059   rv = set->GetFilter(getter_AddRefs( filter ));
1060   NS_TEST_ASSERT_OK(rv);
1061   NS_ENSURE_SUCCESS(rv, rv);
1062
1063   nsCOMPtr<aaIStringFilter> strFilter(do_QueryInterface(filter, &rv));
1064   NS_ENSURE_TRUE(strFilter, rv);
1065   strFilter->SetExpression(NS_LITERAL_CSTRING(" WHERE state.flow_id = 6\
1066         AND state.paid = 2454344"));
1067
1068   rv = set->SetFilter(filter);
1069   NS_TEST_ASSERT_OK(rv);
1070   NS_ENSURE_SUCCESS(rv, rv);
1071
1072   rv = set->Load();
1073   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[stop event] loading states" );
1074
1075   set->GetLength(&count);
1076   NS_TEST_ASSERT_MSG(count == 1, "[stop event] wrong flow count");
1077
1078   state = do_QueryElementAt(set, 0, &rv);
1079   NS_TEST_ASSERT_MSG(state, "[stop event] item not read" );
1080   NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
1081
1082   NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 6, 4, AA_EVENT_AMOUNT_6),
1083       "[stop event] flow6 is wrong");
1084   return NS_OK;
1085 }
1086
1087 nsresult
1088 aaStorageTest::testJunkEvent(nsITestRunner *aTestRunner)
1089 {
1090   NS_TEST_BEGIN(aTestRunner);
1091   nsresult rv;
1092
1093   rv = mFlowSet->Load();
1094   NS_TEST_ASSERT_OK(rv);
1095
1096   nsCOMPtr<aaIFlow> bankAccRub(do_QueryElementAt(mFlowSet,2));
1097   nsCOMPtr<aaIFlow> bankAccEur(do_QueryElementAt(mFlowSet,5));
1098
1099   nsCOMPtr<aaIEvent> node(do_CreateInstance("@aasii.org/base/event;1"));
1100   /* Set time to 2007-08-31 */
1101   PRExplodedTime tm = {0,0,0,12,31,7,2007};
1102   node->SetTime(PR_ImplodeTime(&tm));
1103
1104   nsCOMPtr<nsIMutableArray> block(do_QueryInterface( node ));
1105   NS_ENSURE_TRUE(block, NS_ERROR_UNEXPECTED);
1106
1107   /* Junk Fact */
1108   nsCOMPtr<aaIFact> fact(do_CreateInstance("@aasii.org/base/fact;1"));
1109   fact->SetAmount(1);
1110   fact->SetTakeFrom(bankAccEur);
1111   fact->SetGiveTo(bankAccRub);
1112
1113   rv = block->AppendElement(fact, PR_FALSE);
1114   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[junk event] appending element" );
1115
1116   rv = mSession->Save(node, nsnull);
1117   NS_TEST_ASSERT_MSG(NS_FAILED(rv), "[junk event] saving" );
1118
1119   nsCOMPtr<aaILoadQuery> set;
1120   mSession->CreateQuery(AA_LOADFLOWSTATES_CONTRACT_ID, getter_AddRefs( set ));
1121   NS_TEST_ASSERT_MSG(set, "[junk event] creating loader" );
1122   NS_ENSURE_TRUE(set, rv);
1123
1124   rv = set->Load();
1125   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[junk event] loading states" );
1126
1127   PRUint32 count;
1128   set->GetLength(&count);
1129   NS_TEST_ASSERT_MSG(count == 5, "[junk event] wrong flow count");
1130
1131   nsCOMPtr<aaIState> state;
1132   state = do_QueryElementAt(set, 2, &rv);
1133   NS_TEST_ASSERT_MSG(state, "[junk event] 2nd item not read" );
1134   NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
1135
1136   NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 3, 1, AA_EVENT_AMOUNT_2
1137         + AA_EVENT_AMOUNT_3 - AA_EVENT_AMOUNT_4
1138         - AA_EVENT_AMOUNT_6 * AA_EVENT_RATE_2),
1139       "[junk event] flow3 is wrong");
1140
1141   state = do_QueryElementAt(set, 4, &rv);
1142   NS_TEST_ASSERT_MSG(state, "[junk event] 4th item not read" );
1143   NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
1144
1145   NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 7, 1, AA_EVENT_AMOUNT_6
1146         * AA_EVENT_RATE_3),
1147       "[junk event] flow7 is wrong");
1148   /* Forex deal #2 is paid correctly */
1149
1150   return NS_OK;
1151 }
1152
1153 NS_GENERIC_FACTORY_CONSTRUCTOR(aaStorageTest)
1154
1155 static const nsModuleComponentInfo kComponents[] =
1156 {
1157   {
1158     "Storage Module Unit Test",
1159     AA_STORAGE_TEST_CID,
1160     AA_STORAGE_TEST_CONTRACT_ID,
1161     aaStorageTestConstructor
1162   }
1163 };
1164 NS_IMPL_NSGETMODULE(aabase, kComponents)
1165