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 "nsIArray.h"
  29 #include "nsCOMArray.h"
  30
  31 /* Unfrozen API */
  32 #include "unstable/nsAutoPtr.h"
  33 #include <abstract/cxxunit/nsCxxUnit.h>
  34 #include <abstract/cxxunit/nsITest.h>
  35 #include <abstract/cxxunit/nsITestRunner.h>
  36 #include <unstable/mozIStorageConnection.h>
  37
  38 /* Project includes */
  39 #include <abstract/base/aaIEntity.h>
  40 #include <abstract/base/aaIObject.h>
  41 #include <abstract/base/aaIFlow.h>
  42 #include <abstract/storage/aaISession.h>
  43 #include <abstract/storage/aaIQuery.h>
  44 #include <abstract/storage/aaIDataSource.h>
  45 #include <abstract/storage/aaISaveQuery.h>
  46 #include "aaSession.h"
  47 #include "aaSaveDispatcher.h"
  48 #include "aaDataSource.h"
  49 #include "aaSaveEntity.h"
  50 #include "aaDSEntity.h"
  51 #include "aaSaveObject.h"
  52 #include "aaDSObject.h"
  53 #include "aaSaveFlow.h"
  54 #include "aaDSFlow.h"
  55
  56 #define AA_STORAGE_TEST_CID \
  57 {0x1e7c924e, 0x872d, 0x4c4e, {0xb8, 0x1c, 0x58, 0xd9, 0x66, 0x4a, 0xe9, 0xd1}}
  58 #define AA_STORAGE_TEST_CONTRACT_ID "@aasii.org/storage/unit;1"
  59
  60 class aaStorageTest: public nsITest
  61 {
  62 public:
  63   aaStorageTest() {;}
  64   virtual ~aaStorageTest() {;}
  65   NS_DECL_ISUPPORTS
  66   NS_DECL_NSITEST
  67 private:
  68   nsCOMPtr<aaISession> mSession;
  69   nsresult testSession(nsITestRunner *aTestRunner);
  70   nsresult testSaveDispatcher(nsITestRunner *aTestRunner);
  71   nsresult testSaveEntity(nsITestRunner *aTestRunner);
  72   nsresult testDSEntity(nsITestRunner *aTestRunner);
  73   nsresult testSaveObject(nsITestRunner *aTestRunner);
  74   nsresult testDSObject(nsITestRunner *aTestRunner);
  75   nsresult testSaveFlow(nsITestRunner *aTestRunner);
  76   nsresult testDSFlow(nsITestRunner *aTestRunner);
  77 };
  78
  79 NS_IMPL_ISUPPORTS1(aaStorageTest, nsITest);
  80
  81 NS_IMETHODIMP
  82 aaStorageTest::Test(nsITestRunner *aTestRunner)
  83 {
  84   testSession(aTestRunner);
  85   testSaveDispatcher(aTestRunner);
  86   testSaveEntity(aTestRunner);
  87   testDSEntity(aTestRunner);
  88   testSaveObject(aTestRunner);
  89   testDSObject(aTestRunner);
  90   testSaveFlow(aTestRunner);
  91   testDSFlow(aTestRunner);
  92   return NS_OK;
  93 }
  94
  95 NS_IMETHODIMP
  96 aaStorageTest::GetAsync(PRBool *aAsync)
  97 {
  98   NS_ENSURE_ARG_POINTER( aAsync );
  99   *aAsync = PR_FALSE;
 100   return NS_OK;
 101 }
 102
 103 nsresult
 104 aaStorageTest::testSession(nsITestRunner *aTestRunner)
 105 {
 106   nsresult rv;
 107
 108   NS_TEST_BEGIN(aTestRunner);
 109   mSession = do_CreateInstance(AA_SESSION_CONTRACT_ID);
 110   NS_TEST_ASSERT_MSG(mSession, "aaSession instance creation" );
 111
 112   aaSession *session = NS_STATIC_CAST(aaSession *, mSession.get());
 113   NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
 114
 115   NS_TEST_ASSERT_MSG( session->mConnection, "session.connection failed" );
 116
 117   PRBool choosing = PR_TRUE;
 118   rv = session->GetChoosing( &choosing );
 119   NS_TEST_ASSERT_OK( rv );
 120   NS_TEST_ASSERT_MSG(! choosing, "session should not be in choice mode");
 121
 122   rv = session->BeginQuery();
 123   NS_TEST_ASSERT_OK( rv );
 124   rv = session->BeginQuery();
 125   NS_TEST_ASSERT_MSG(rv == NS_ERROR_ALREADY_INITIALIZED,
 126       "only one query at a time");
 127
 128   rv = session->GetChoosing( &choosing );
 129   NS_TEST_ASSERT_OK( rv );
 130   NS_TEST_ASSERT_MSG(choosing, "session should be in choice mode");
 131
 132   rv = session->GetChoosing( &choosing );
 133   NS_TEST_ASSERT_OK( rv );
 134   NS_TEST_ASSERT_MSG(! choosing, "session should not be in choice mode");
 135
 136   return NS_OK;
 137 }
 138
 139 nsresult
 140 aaStorageTest::testSaveDispatcher(nsITestRunner *aTestRunner)
 141 {
 142   NS_TEST_BEGIN(aTestRunner);
 143   nsresult rv;
 144
 145   nsCOMPtr<aaIQuery> saver(do_CreateInstance(
 146         AA_SAVEDISPATCHER_CONTRACT_ID, mSession, &rv));
 147   NS_TEST_ASSERT_MSG(saver, "'saveDispatcher' instance creation" );
 148   NS_ENSURE_SUCCESS(rv, rv);
 149
 150   return NS_OK;
 151 }
 152
 153 nsresult
 154 aaStorageTest::testSaveEntity(nsITestRunner *aTestRunner)
 155 {
 156   NS_TEST_BEGIN(aTestRunner);
 157   nsresult rv;
 158
 159   aaSession *session = NS_STATIC_CAST(aaSession *, mSession.get());
 160   NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
 161
 162   nsCOMPtr<aaISaveQuery> saver(do_CreateInstance(
 163         AA_SAVEENTITY_CONTRACT_ID, session->mConnection, &rv));
 164   NS_TEST_ASSERT_MSG(saver, "'saveEntity' instance creation" );
 165   NS_ENSURE_SUCCESS(rv, rv);
 166
 167   return NS_OK;
 168 }
 169
 170 nsresult
 171 aaStorageTest::testDSEntity(nsITestRunner *aTestRunner)
 172 {
 173   nsresult rv;
 174   NS_TEST_BEGIN(aTestRunner);
 175
 176   nsCOMPtr<aaIDataSource> entities(do_CreateInstance(
 177         AA_DSENTITY_CONTRACT_ID,&rv));
 178   NS_TEST_ASSERT_MSG(entities, "aaDSEntity instance creation" );
 179   NS_ENSURE_SUCCESS(rv, rv);
 180
 181   aaDSEntity *entityDS = NS_STATIC_CAST(aaDSEntity *, entities.get());
 182
 183   aaSession *session = NS_STATIC_CAST(aaSession *, mSession.get());
 184   NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
 185
 186   rv = entityDS->Init(session->mConnection);
 187   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "aaDSEntity initialization" );
 188   NS_ENSURE_SUCCESS(rv, rv);
 189
 190   rv = entityDS->BeginAdd();
 191   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv) && entityDS->mBuffer,
 192       "aaDSEntity buffer creation" );
 193   NS_ENSURE_SUCCESS(rv, rv);
 194   nsCOMPtr<aaIEntity> entity(do_QueryInterface(entityDS->mBuffer));
 195   entity->SetTag(NS_LITERAL_STRING("abstract"));
 196   rv = entityDS->Save(mSession);
 197   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "aaDSEntity insertion" );
 198   rv = entityDS->BeginAdd();
 199   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv) && entityDS->mBuffer,
 200       "aaDSEntity buffer creation" );
 201   entity = do_QueryInterface(entityDS->mBuffer);
 202   entity->SetTag(NS_LITERAL_STRING("Sergey"));
 203   rv = entityDS->Save(mSession);
 204   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "aaDSEntity second insertion" );
 205   return NS_OK;
 206 }
 207
 208 nsresult
 209 aaStorageTest::testSaveObject(nsITestRunner *aTestRunner)
 210 {
 211   NS_TEST_BEGIN(aTestRunner);
 212   nsresult rv;
 213
 214   aaSession *session = NS_STATIC_CAST(aaSession *, mSession.get());
 215   NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
 216
 217   nsCOMPtr<aaISaveQuery> saver(do_CreateInstance(
 218         AA_SAVEOBJECT_CONTRACT_ID, session->mConnection, &rv));
 219   NS_TEST_ASSERT_MSG(saver, "'saveObject' instance creation" );
 220   NS_ENSURE_SUCCESS(rv, rv);
 221
 222   return NS_OK;
 223 }
 224
 225 nsresult
 226 aaStorageTest::testDSObject(nsITestRunner *aTestRunner)
 227 {
 228   nsresult rv;
 229   NS_TEST_BEGIN(aTestRunner);
 230
 231   nsCOMPtr<aaIDataSource> iObjects(do_CreateInstance(
 232         AA_DSOBJECT_CONTRACT_ID,&rv));
 233   NS_TEST_ASSERT_MSG(iObjects, "aaDSObject instance creation" );
 234   NS_ENSURE_SUCCESS(rv, rv);
 235
 236   aaSession *session = NS_STATIC_CAST(aaSession *, mSession.get());
 237   NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
 238
 239   rv = iObjects->Init(session->mConnection);
 240   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "aaDSObject initialization" );
 241   NS_ENSURE_SUCCESS(rv, rv);
 242
 243   nsCOMPtr<aaIDataSet> objects;
 244   rv = mSession->GetObjects(getter_AddRefs( objects ));
 245   NS_ENSURE_SUCCESS(rv, rv);
 246   iObjects = do_QueryInterface(objects, &rv);
 247   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "session.objects" );
 248
 249   aaDSObject *objectDS = NS_STATIC_CAST(aaDSObject *, iObjects.get());
 250
 251   rv = objectDS->BeginAdd();
 252   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv) && objectDS->mBuffer,
 253       "aaDSObject buffer creation" );
 254   NS_ENSURE_SUCCESS(rv, rv);
 255   nsCOMPtr<aaIObject> object(do_QueryInterface(objectDS->mBuffer));
 256   object->SetTag(NS_LITERAL_STRING("RUB"));
 257   rv = objectDS->Save(session);
 258   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "aaDSObject insertion" );
 259   rv = objectDS->BeginAdd();
 260   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv) && objectDS->mBuffer,
 261       "aaDSObject buffer creation" );
 262   NS_ENSURE_SUCCESS(rv, rv);
 263   object = do_QueryInterface(objectDS->mBuffer);
 264   object->SetTag(NS_LITERAL_STRING("USD"));
 265   rv = objectDS->Save(session);
 266   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "aaDSObject second insertion" );
 267   return NS_OK;
 268 }
 269
 270 nsresult
 271 aaStorageTest::testSaveFlow(nsITestRunner *aTestRunner)
 272 {
 273   NS_TEST_BEGIN(aTestRunner);
 274   nsresult rv;
 275
 276   aaSession *session = NS_STATIC_CAST(aaSession *, mSession.get());
 277   NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
 278
 279   nsCOMPtr<aaISaveQuery> saver(do_CreateInstance(
 280         AA_SAVEFLOW_CONTRACT_ID, session->mConnection, &rv));
 281   NS_TEST_ASSERT_MSG(saver, "'saveflow' instance creation" );
 282   NS_ENSURE_SUCCESS(rv, rv);
 283
 284   return NS_OK;
 285 }
 286
 287 #define AA_FLOW_TAG_1 "equity share 1"
 288 #define AA_FLOW_TAG_2 "equity share 2"
 289
 290 nsresult
 291 aaStorageTest::testDSFlow(nsITestRunner *aTestRunner)
 292 {
 293   nsresult rv;
 294   NS_TEST_BEGIN(aTestRunner);
 295
 296   nsCOMPtr<aaIDataSource> iFlows(do_CreateInstance(
 297         AA_DSFLOW_CONTRACT_ID,&rv));
 298   NS_TEST_ASSERT_MSG(iFlows, "aaDSFlow instance creation" );
 299   NS_ENSURE_SUCCESS(rv, rv);
 300
 301   aaSession *session = NS_STATIC_CAST(aaSession *, mSession.get());
 302   NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
 303
 304   rv = iFlows->Init(session->mConnection);
 305   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "aaDSFlow initialization" );
 306   NS_ENSURE_SUCCESS(rv, rv);
 307
 308   nsCOMPtr<aaIDataSet> flows;
 309   rv = mSession->GetFlows(getter_AddRefs( flows ));
 310   NS_ENSURE_SUCCESS(rv, rv);
 311   iFlows = do_QueryInterface(flows, &rv);
 312   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "session.flows" );
 313
 314   aaDSFlow *flowDS = NS_STATIC_CAST(aaDSFlow *, iFlows.get());
 315
 316   rv = flowDS->BeginAdd();
 317   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv) && flowDS->mBuffer,
 318       "aaDSFlow buffer creation" );
 319   NS_ENSURE_SUCCESS(rv, rv);
 320   nsCOMPtr<aaIFlow> flow(do_QueryInterface(flowDS->mBuffer));
 321   flow->SetTag(NS_LITERAL_STRING(AA_FLOW_TAG_1));
 322   rv = flowDS->Save(session);
 323   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "aaDSFlow insertion" );
 324   nsCOMPtr<nsISupports> readSupp;
 325   rv = flows->QueryElementAt(0, NS_GET_IID(nsISupports),
 326       getter_AddRefs(readSupp));
 327   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "aaDSFlow read after insert" );
 328   nsCOMPtr<aaIFlow> readFlow(do_QueryInterface(readSupp));
 329   nsEmbedString tag;
 330   readFlow->GetTag(tag);
 331   NS_TEST_ASSERT_MSG(tag.Equals(NS_LITERAL_STRING(AA_FLOW_TAG_1)),
 332       "aaDSFlow read after insert" );
 333   rv = flowDS->BeginAdd();
 334   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv) && flowDS->mBuffer,
 335       "aaDSFlow buffer creation" );
 336   NS_ENSURE_SUCCESS(rv, rv);
 337   flow = do_QueryInterface(flowDS->mBuffer);
 338   flow->SetTag(NS_LITERAL_STRING(AA_FLOW_TAG_2));
 339   rv = flowDS->Save(session);
 340   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "aaDSFlow second insertion" );
 341   return NS_OK;
 342 }
 343
 344 NS_GENERIC_FACTORY_CONSTRUCTOR(aaStorageTest)
 345
 346 static const nsModuleComponentInfo kComponents[] =
 347 {
 348   {
 349     "Storage Module Unit Test",
 350     AA_STORAGE_TEST_CID,
 351     AA_STORAGE_TEST_CONTRACT_ID,
 352     aaStorageTestConstructor
 353   }
 354 };
 355 NS_IMPL_NSGETMODULE(aabase, kComponents)
 356