open_ehr 0.6.1

data/spec/lib/open_ehr/rm/common/change_control/versioned_object_spec.rb

@@ -0,0 +1,285 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+#require File.dirname(__FILE__) + '/shared_examples_spec'
+include OpenEHR::RM::Common::ChangeControl
+include OpenEHR::RM::Common::Generic
+include OpenEHR::RM::DataTypes::Quantity::DateTime
+include OpenEHR::RM::DataTypes::Text
+
+describe VersionedObject do
+  before(:each) do
+    uid1 = ObjectVersionID.new(:value => 'ABC::DEF::1')
+    defining_code1 = stub(CodePhrase, :code_string => '532')
+    lifecycle_state1 = stub(DvCodedText, :defining_code => defining_code1)
+    time_committed1 = DvDateTime.new(:value => '2008-11-12T18:24:32')
+    audit_details1 = stub(AuditDetails, :time_committed => time_committed1)
+    version1 = stub(Version, :commit_audit => audit_details1,
+                             :lifecycle_state => lifecycle_state1,
+                             :uid => uid1)
+    uid2 = ObjectVersionID.new(:value => 'GHI::JKL::2')
+    defining_code2 = stub(CodePhrase, :code_string => '553')
+    lifecycle_state2 = stub(DvCodedText, :defining_code => defining_code2)
+    time_committed2 = DvDateTime.new(:value => '2008-12-12T19:32:14')
+    audit_details2 = stub(AuditDetails, :time_committed => time_committed2)
+    attestation = stub(Attestation)
+    attestations = Array.new([attestation])
+    contribution = stub(ObjectRef, :empty? => false, :type => 'CONTRIBUTION')
+    version2 = OriginalVersion.new(:commit_audit => audit_details2,
+                                   :lifecycle_state => lifecycle_state2,
+                                   :preceding_version_uid => uid1,
+                                   :uid => uid2,
+                                   :contribution => contribution,
+                                   :attestations => attestations)
+    uid3 = ObjectVersionID.new(:value => 'MNO::PQR::3')
+    defining_code3 = stub(CodePhrase, :code_string => '523')
+    lifecycle_state3 = stub(DvCodedText, :defining_code => defining_code3)
+    time_committed3 = DvDateTime.new(:value => '2009-07-15T09:24:26')
+    audit_details3 = stub(AuditDetails, :time_committed => time_committed3)
+    version3 = stub(Version, :commit_audit => audit_details3,
+                             :lifecycle_state => lifecycle_state3,
+                             :uid => uid3)
+    uid = HierObjectID.new(:value => 'STU::VWX::5')
+    owner_id = stub(ObjectRef, :namespace => 'test')
+    time_created = DvDateTime.new(:value => '2009-11-09T09:53:22')
+    object_id = stub(ObjectID, :value => 'unique')
+    all_versions = [version1, version2, version3]
+    @versioned_object = VersionedObject.new(:uid => uid,
+                                            :owner_id => owner_id,
+                                            :time_created => time_created,
+                                            :all_versions => all_versions)
+  end
+
+  it 'should be an instance of VersionedObject' do
+    @versioned_object.should be_an_instance_of VersionedObject
+  end
+
+  it 'uid value should be STU::VWX::5' do
+    @versioned_object.uid.value.should == 'STU::VWX::5'
+  end
+
+  it 'owner_id namespace should be test' do
+    @versioned_object.owner_id.namespace.should == 'test'
+  end
+
+  it 'all_versions.size should be 3' do
+    @versioned_object.all_versions.size.should == 3
+  end
+
+  it 'version_count should be 3' do
+    @versioned_object.version_count.should == 3
+  end
+
+  it 'time_created should equal 2009-11-09T09:53:22' do
+    @versioned_object.time_created.value.should == '2009-11-09T09:53:22'
+  end
+
+  it 'all_version_ids should return all ids of versions' do
+    ids = @versioned_object.all_version_ids
+    ids.each do |id|
+      %w(ABC::DEF::1 GHI::JKL::2 MNO::PQR::3).should include id.value
+    end
+  end
+
+  it 'should have version id ABC::DEF::1' do
+    object_version_id = ObjectVersionID.new(:value => 'ABC::DEF::1')
+    @versioned_object.has_version_id?(object_version_id).should be_true
+  end
+
+  it 'should not have version id BCD::EFG::12' do
+    object_version_id = ObjectVersionID.new(:value => 'BCD::EFG::12')
+    @versioned_object.has_version_id?(object_version_id).should be_false
+  end
+
+  it 'ABC::DEF::1 should not be original version' do
+    object_version_id = ObjectVersionID.new(:value => 'ABC::DEF::1')
+    @versioned_object.is_original_version?(object_version_id).should be_false
+  end
+
+  it 'GHI::JKL::2 should be original version' do
+    object_version_id = ObjectVersionID.new(:value => 'GHI::JKL::2')
+    @versioned_object.is_original_version?(object_version_id).should be_true
+  end
+
+  it 'should have 2009-07-15T09:24:26 committed version' do
+    exist_time = DvDateTime.new(:value => '2009-07-15T09:24:26')
+    @versioned_object.has_version_at_time?(exist_time).should be_true
+  end
+
+  it 'should retrun version3 with id MNO::PQR::3' do
+    uid = ObjectVersionID.new(:value => 'MNO::PQR::3')
+    @versioned_object.version_with_id(uid).commit_audit.time_committed.
+      should == DvDateTime.new(:value => '2009-07-15T09:24:26')
+  end
+
+  it 'should return version2 with 2008-12-12T19:32:14' do
+    exist_date = DvDateTime.new(:value => '2008-12-12T19:32:14')
+    @versioned_object.version_at_time(exist_date).lifecycle_state.
+      defining_code.code_string.should == '553'
+  end
+
+  it 'latest_version should return version3' do
+    @versioned_object.latest_version.uid.value.should == 'MNO::PQR::3'
+  end
+
+  it 'latest_trunk_version should return ABC::DEF::1' do
+    @versioned_object.latest_trunk_version.uid.value.should ==
+      'ABC::DEF::1'
+  end
+
+  it 'trunk_lifecycle_state should return 532' do
+    @versioned_object.trunk_lifecycle_state.defining_code.
+      code_string.should == '532'
+  end
+
+  it 'revision_history items are 3' do
+    @versioned_object.revision_history.items.size.should == 3
+  end
+
+  it 'should be able to commit original version' do
+    contribution = stub(ObjectRef, :empty? => false, :type => 'CONTRIBUTION')
+    uid = ObjectVersionID.new(:value => 'EFG::HIJ::7')
+    preceding_version_uid = ObjectVersionID.new(:value => 'ABC::DEF::1')
+    audit = stub(AuditDetails)
+    defining_code = stub(CodePhrase, :code_string => '523')
+    lifecycle_state = stub(DvCodedText, :defining_code => defining_code)
+    attestations = stub(Array, :empty? => false)
+    @versioned_object.
+      commit_original_version(:contribution => contribution,
+                              :uid => uid,
+                              :preceding_version_uid => preceding_version_uid,
+                              :commit_audit => audit,
+                              :lifecycle_state => lifecycle_state,
+                              :data => 'data',
+                              :attestations => attestations,
+                              :signature => 'A41bdad')
+    @versioned_object.all_versions.size.should == 4
+  end
+
+  it 'should raise ArgumentError with invalid preceeding version' do
+    contribution = stub(ObjectRef, :empty? => false, :type => 'CONTRIBUTION')
+    uid = ObjectVersionID.new(:value => 'EFG::HIJ::7')
+    preceding_version_uid = ObjectVersionID.new(:value => 'BCD::EFG::8')
+    audit = stub(AuditDetails)
+    defining_code = stub(CodePhrase, :code_string => '523')
+    lifecycle_state = stub(DvCodedText, :defining_code => defining_code)
+    attestations = stub(Array, :empty? => false)
+    lambda {
+      @versioned_object.
+      commit_original_version(:contribution => contribution,
+                              :uid => uid,
+                              :preceding_version_uid => preceding_version_uid,
+                              :commit_audit => audit,
+                              :lifecycle_state => lifecycle_state,
+                              :data => 'data',
+                              :attestations => attestations,
+                              :signature => 'A41bdad')
+    }.should raise_error ArgumentError
+  end
+
+  it 'should be able to commit original merged version' do
+    contribution = stub(ObjectRef, :empty? => false, :type => 'CONTRIBUTION')
+    uid = ObjectVersionID.new(:value => 'KLM::NOP::9')
+    preceding_version_uid = ObjectVersionID.new(:value => 'ABC::DEF::1')
+    time_committed = DvDateTime.new(:value => '2009-11-09T23:42:18')
+    audit = stub(AuditDetails, :time_committed => time_committed)
+    defining_code = stub(CodePhrase, :code_string => '523')
+    lifecycle_state = stub(DvCodedText, :defining_code => defining_code)
+    attestations = stub(Array, :empty? => false)
+    @versioned_object.
+      commit_original_merged_version(:contribution => contribution,
+                              :uid => uid,
+                              :preceding_version_uid => preceding_version_uid,
+                              :commit_audit => audit,
+                              :lifecycle_state => lifecycle_state,
+                              :data => 'merged data',
+                              :attestations => attestations,
+                              :signature => 'dc3dbdad')
+    @versioned_object.latest_version.data.should == 'merged data'
+  end
+
+  it 'should be able to commit imported_version' do
+    contribution = stub(ObjectRef, :empty? => false, :type => 'CONTRIBUTION')
+    time_committed = DvDateTime.new(:value => '2009-11-09T23:42:18')
+    audit = stub(AuditDetails, :time_committed => time_committed)
+    uid = ObjectVersionID.new(:value => 'QRS::TUV::10')
+    preceding_version_uid = ObjectVersionID.new(:value => 'ABC::DEF::1')
+    defining_code = stub(CodePhrase, :code_string => '523')
+    lifecycle_state = stub(DvCodedText, :defining_code => defining_code)
+    attestations = stub(Array, :empty? => false)
+    original_version = OriginalVersion.new(:uid => uid,
+                            :contribution => contribution,
+                            :commit_audit => audit,
+                            :preceding_version_uid => preceding_version_uid,
+                            :data => 'original data',
+                            :lifecycle_state => lifecycle_state,
+                            :attestations => attestations)
+    @versioned_object.commit_imported_version(:contribution => contribution,
+                                              :commit_audit => audit,
+                                              :item => original_version)
+    @versioned_object.latest_version.commit_audit.time_committed.value.
+      should == '2009-11-09T23:42:18'
+  end
+
+  it 'should be able to commit attestation' do
+    attestation = stub(Attestation)
+    uid = ObjectVersionID.new(:value => 'GHI::JKL::2')
+    @versioned_object.commit_attestation(:attestation => attestation,
+                                         :uid => uid,
+                                         :signature => 'CDAEbad')
+    @versioned_object.version_with_id(uid).signature.
+      should == 'CDAEbad'
+  end
+
+  it 'should raise ArgumentError when time_created is nil' do
+    lambda {
+      @versioned_object.time_created = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError when all_versions are nil' do
+    lambda {
+      @versioned_object.all_versions = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError when is_original_version argument is nil' do
+    lambda {
+      @versioned_object.is_original_version?(nil)
+    }.should raise_error ArgumentError
+  end
+
+  it 'should not has time data' do
+    unexisted_time = DvDateTime.new(:value => '2009-11-10T00:43:59')
+    lambda {
+      @versioned_object.version_at_time(unexisted_time)
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError with nil argument to commit_attestations' do
+    lambda {
+      @versioned_object.commit_attestation(:attestation => nil)
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError with not orinigal version id' do
+    uid = ObjectVersionID.new(:value => 'ABC::DEF::1')
+    attestation = stub(Attestation)
+    lambda {
+      @versioned_object.commit_attestation(:attestation => attestation,
+                                           :uid => uid,
+                                           :signature => 'DEADBEAFE81')
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError with nil argument to version with id' do
+    lambda {
+      @versioned_object.version_with_id(nil)
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError with unexsited version with id ' do
+    uid = ObjectVersionID.new(:value => 'CBA::FED::1')
+    lambda {
+      @versioned_object.version_with_id(uid)
+    }.should raise_error ArgumentError
+  end
+end

data/spec/lib/open_ehr/rm/common/directory/folder_spec.rb

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::Common::Directory
+include OpenEHR::RM::DataTypes::Text
+
+describe Folder do
+  before(:each) do
+    items = stub(Array, :size => 3)
+    folders = stub(Array, :size => 5, :empty? => false)
+    @folder = Folder.new(:archetype_node_id => 'at0001',
+                         :name => DvText.new(:value => 'test'),
+                         :items => items,
+                         :folders => folders)
+  end
+
+  it 'should an instance of Folder' do
+    @folder.should be_an_instance_of Folder
+  end
+
+  it 'items size should be 3' do
+    @folder.items.size.should == 3
+  end
+
+  it 'folders size should be 5' do
+    @folder.folders.size.should == 5
+  end
+end

data/spec/lib/open_ehr/rm/common/generic/attestation_spec.rb

@@ -0,0 +1,62 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::Common::Generic
+include OpenEHR::RM::Support::Identification
+include OpenEHR::RM::DataTypes::Text
+include OpenEHR::RM::DataTypes::Quantity::DateTime
+include OpenEHR::RM::DataTypes::Encapsulated
+
+describe Attestation do
+  before(:each) do
+    committer = stub(PartyProxy, :namespace => 'UNKNOWN')
+    change_type = stub(DvCodedText, :value =>'creation')
+    time = stub(DvDateTime, :value => '2009-10-03T16:24:19.0Z')
+    reason = DvText.new(:value => 'signed')
+    items = stub(Set, :empty? => false, :size => 3)
+    attested_view = stub(DvMultimedia, :size => 300)
+    @attestation = Attestation.new(:committer => committer,
+                                   :change_type => change_type,
+                                   :time_committed => time,
+                                   :system_id => 'test',
+                                   :reason => reason,
+                                   :proof => 'DEADBEEFBABE',
+                                   :is_pending => true,
+                                   :attested_view => attested_view,
+                                   :items => items)
+  end
+
+  it 'should be an instance of Attestation' do
+    @attestation.should be_an_instance_of Attestation
+  end
+
+  it 'reason should be signed' do
+    @attestation.reason.value.should == 'signed'
+  end
+
+  it 'proof should DEADBEEFBABE' do
+    @attestation.proof.should == 'DEADBEEFBABE'
+  end
+
+  it 'attested view size should be 300' do
+    @attestation.attested_view.size.should == 300
+  end
+
+  it 'is_pending? should true' do
+    @attestation.is_pending?.should be_true
+  end
+
+  it 'items size should be 30' do
+    @attestation.items.size.should == 3
+  end
+
+  it 'should raise ArgumentError when items are empty' do
+    lambda {
+      @attestation.items = Set.new
+    }.should raise_error ArgumentError
+  end
+
+  it 'should not raise ArgumentErro when items are nil' do
+    lambda {
+      @attestation.items = nil
+    }.should_not raise_error ArgumentError
+  end
+end

data/spec/lib/open_ehr/rm/common/generic/audit_details_spec.rb

@@ -0,0 +1,51 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::Common::Generic
+include OpenEHR::RM::Support::Identification
+include OpenEHR::RM::DataTypes::Text
+include OpenEHR::RM::DataTypes::Quantity::DateTime
+
+describe AuditDetails do
+  before(:each) do
+    committer = stub(PartyProxy, :namespace => 'UNKNOWN')
+    change_type = stub(DvCodedText, :value =>'creation')
+    time = stub(DvDateTime, :value => '2009-10-03T16:24:19.0Z')
+    desc = DvText.new(:value => 'test environment')
+    @audit_details = AuditDetails.new(:system_id => 'MAGI',
+                                      :committer => committer,
+                                      :time_committed => time,
+                                      :change_type => change_type,
+                                      :description => desc)
+  end
+
+  it 'should be an instance of AuditDetails' do
+    @audit_details.should be_an_instance_of AuditDetails
+  end
+
+  it 'system_id should be MAGI' do
+    @audit_details.system_id.should == 'MAGI'
+  end
+
+  it 'committer namespece should be UNKNOWN' do
+    @audit_details.committer.namespace.should == 'UNKNOWN'
+  end
+
+  it 'change_type.value should be creation' do
+    @audit_details.change_type.value.should == 'creation'
+  end
+
+  it 'description should be test environment' do
+    @audit_details.description.value.should == 'test environment'
+  end
+
+  it 'should raise ArgumentError when system_id was assigned nil' do
+    lambda {
+      @audit_details.system_id = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError when time_commited is nil' do
+    lambda {
+      @audit_details.time_committed = nil
+    }.should raise_error ArgumentError
+  end
+end

data/spec/lib/open_ehr/rm/common/generic/participation_spec.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::Common::Generic
+
+describe Participation do
+  before(:each) do
+    performer = stub(PartyProxy, :name => 'GEHIRN')
+    function = stub(DvText, :value => 'committer')
+    mode = stub(DvCodedText, :value => 'present')
+    lower = stub(DvDateTime, :value => '2009-10-03T20:33:05')
+    time = stub(DvInterval, :lower => lower)
+    @participation = Participation.new(:performer => performer,
+                                       :function => function,
+                                       :mode => mode,
+                                       :time => time)
+  end
+
+  it 'should be an instance of Participation' do
+    @participation.should be_an_instance_of Participation
+  end
+
+  it 'should assign performer properly' do
+    @participation.performer.name.should == 'GEHIRN'
+  end
+
+  it 'should assign function properly' do
+    @participation.function.value.should == 'committer'
+  end
+
+  it 'should assign mode properly' do
+    @participation.mode.value.should == 'present'
+  end
+
+  it 'should assign time properly' do
+    @participation.time.lower.value.should == '2009-10-03T20:33:05'
+  end
+end

data/spec/lib/open_ehr/rm/common/generic/party_identified_spec.rb

@@ -0,0 +1,64 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::Common::Generic
+
+describe PartyIdentified do
+  before(:each) do
+    external_ref = stub(PartyRef, :namespace => 'unknown')
+    identifiers = stub(Array, :size => 5, :empty? => false)
+    @party_identified = PartyIdentified.new(:name => 'NERV',
+                                            :external_ref => external_ref,
+                                            :identifier => identifiers)
+  end
+
+  it 'should be an instance of PartyIdentified' do
+    @party_identified.should be_an_instance_of PartyIdentified
+  end
+
+  it 'should assign name properly' do
+    @party_identified.name.should == 'NERV'
+  end
+
+  it 'should assign external_ref properly' do
+    @party_identified.external_ref.namespace.should == 'unknown'
+  end
+
+  it 'should assign identifier properly' do
+    @party_identified.identifier.size.should be_equal 5
+  end
+
+  it 'should raise ArgumentError with all nil' do
+    lambda {
+      PartyIdentified.new
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError with nil name when ex_r and id nil' do
+    @party_identified.identifier = nil
+    @party_identified.external_ref = nil
+    lambda {
+      @party_identified.name = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError with nil external_ref when name and id nil' do
+    @party_identified.name = nil
+    @party_identified.identifier = nil
+    lambda {
+      @party_identified.external_ref = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError with nil identifier when name and ex_r nil' do
+    @party_identified.name = nil
+    @party_identified.external_ref = nil
+    lambda {
+      @party_identified.identifier = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError with empty identifier' do
+    lambda {
+      @party_identified.identifier = Array.new
+    }.should raise_error ArgumentError
+  end
+end

data/spec/lib/open_ehr/rm/common/generic/party_proxy_spec.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::Common::Generic
+include OpenEHR::RM::Support::Identification
+
+describe PartyProxy do
+  before(:each) do
+    external_ref = stub(PartyRef, :namespace => 'NERV')
+    @party_proxy = PartyProxy.new(:external_ref => external_ref)
+  end
+
+  it 'should be an isntance of PartyProxy' do
+    @party_proxy.should be_an_instance_of PartyProxy
+  end
+
+  it 'exnternal_ref.namespace should be NERV' do
+    @party_proxy.external_ref.namespace.should == 'NERV'
+  end
+end

data/spec/lib/open_ehr/rm/common/generic/party_related_spec.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::Common::Generic
+include OpenEHR::RM::DataTypes::Text
+describe PartyRelated do
+  before(:each) do
+    relationship = stub(DvCodedText, :value => 'self')
+    @party_related = PartyRelated.new(:name => 'TEST',
+                                      :relationship => relationship)
+  end
+
+  it 'should be an instance of PartyRelated' do
+    @party_related.should be_an_instance_of PartyRelated
+  end
+
+  it 'should assign relationship properly' do
+    @party_related.relationship.value.should == 'self'
+  end
+
+  it 'should raise ArgumentError when nil is assigned to relationship' do
+    lambda {
+      @party_related.relationship = nil
+    }.should raise_error ArgumentError
+  end
+end

data/spec/lib/open_ehr/rm/common/generic/revision_history_item_spec.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::Common::Generic
+include OpenEHR::RM::Support::Identification
+
+describe RevisionHistoryItem do
+  before(:each)do
+    version_id = stub(ObjectVersionID, :object_id => 'RIO')
+    audits = stub(Array, :size => 30, :empty? => false)
+    @revision_history_item =
+      RevisionHistoryItem.new(:version_id => version_id,
+                              :audits => audits)
+  end
+
+  it 'should be an instance of RevisionHistoryItem' do
+    @revision_history_item.should be_an_instance_of RevisionHistoryItem
+  end
+
+  it 's version_id.object_id should be RIO' do
+    @revision_history_item.version_id.object_id.should == 'RIO'
+  end
+
+  it 's audits.size should be 30' do
+    @revision_history_item.audits.size.should be_equal 30
+  end
+
+  it 'should raise ArgumentError when nil is assigned to version id' do
+    lambda {
+      @revision_history_item.version_id = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError when nil is assinged to audits' do
+    lambda {
+      @revision_history_item.audits = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError when empty is assinged to audits' do
+    lambda {
+      @revision_history_item.audits = Array.new
+    }.should raise_error ArgumentError
+  end
+end

data/spec/lib/open_ehr/rm/common/generic/revision_history_spec.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::Common::Generic
+include OpenEHR::RM::Support::Identification
+include OpenEHR::RM::DataTypes::Quantity::DateTime
+
+describe RevisionHistory do
+  before(:each) do
+    version_id = stub(ObjectVersionID, :value => 'ABCD::EFGH::1')
+    committed_time = stub(DvDateTime, :value => '2009-11-02T22:19:34')
+    audit = stub(AuditDetails, :time_committed => committed_time)
+    audits = stub(Array, :first => audit)
+    last_item = stub(RevisionHistoryItem, :version_id => version_id,
+                     :audits => audits)
+    items = stub(Array, :size => 128, :empty? => false, :last => last_item)
+    @revision_history = RevisionHistory.new(:items => items)
+  end
+
+  it 'should be an instance of RevisionHistory' do
+    @revision_history.should be_an_instance_of RevisionHistory
+  end
+
+  it 'items size should return size 128' do
+    @revision_history.items.size.should be_equal 128
+  end
+
+  it 'should return the most recent version string' do
+    @revision_history.most_recent_version.should == 'ABCD::EFGH::1'
+  end
+
+  it 'should return the most recent commited version time string' do
+    @revision_history.most_recent_version_time_committed == '2009-11-02T22:19:34'
+  end
+
+  it 'should raise ArgumentError when item is nil' do
+    lambda {
+      @revision_history.items = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError when item is empty' do
+    lambda {
+      @revision_history.items = Array.new
+    }.should raise_error ArgumentError
+  end
+end