cybercoach 0.3.0 → 0.4.0

data/lib/cybercoach/user.rb

@@ -45,11 +45,11 @@ module CyberCoach
     #
 
     attr_accessor :username,
-      :email,
-      :password,
-      :real_name,
-      :privacy_level,
-      :date_created
+                  :email,
+                  :password,
+                  :real_name,
+                  :privacy_level,
+                  :date_created
 
     #
     # :category: Serialization
@@ -155,5 +155,9 @@ module CyberCoach
     def invalidate_options
       @options = @options.merge(authentication)
     end
+
+    def initializable_with
+      super + [:username, :email, :password, :real_name, :privacy_level]
+    end
   end
 end

data/lib/cybercoach/version.rb

@@ -6,5 +6,5 @@ module CyberCoach
   #
   # The current version of the gem.
   #
-  VERSION = '0.3.0'
+  VERSION = '0.4.0'
 end

data/spec/lib/cybercoach/entry_spec.rb

@@ -2,8 +2,8 @@ require 'spec_helper'
 
 describe 'Entry' do
   before(:context) do
-    @proposer = UserHelper.make(6)
-    @proposed = UserHelper.make(7)
+    @proposer = UserHelper.make(8)
+    @proposed = UserHelper.make(9)
     ResourceHelper.safe_delete(@proposer)
     ResourceHelper.safe_delete(@proposed)
     @proposer.create
@@ -12,10 +12,10 @@ describe 'Entry' do
     @partnership.proposer = @proposer
     @partnership.proposed = @proposed
     @partnership.privacy_level = CyberCoach::PrivacyLevel::REGISTERED_USER
-    ResourceHelper.safe_delete(@partnership, UserHelper.options(@proposer))
-    ResourceHelper.safe_delete(@partnership, UserHelper.options(@proposed))
-    @partnership.create(UserHelper.options(@proposer))
-    @partnership.update(UserHelper.options(@proposed))
+    ResourceHelper.safe_delete(@partnership, @proposer.authentication)
+    ResourceHelper.safe_delete(@partnership, @proposed.authentication)
+    @partnership.create(@proposer.authentication)
+    @partnership.update(@proposed.authentication)
     @sport = CyberCoach::Sport.new
     @sport.name = 'Running'
     @sport.read
@@ -23,13 +23,13 @@ describe 'Entry' do
     @subscription.subscriber = @partnership
     @subscription.sport = @sport
     @subscription.privacy_level = CyberCoach::PrivacyLevel::REGISTERED_USER
-    @subscription.create(UserHelper.options(@proposer))
+    @subscription.create(@proposer.authentication)
   end
 
   after(:context) do
-    ResourceHelper.safe_delete(@subscription, UserHelper.options(@proposer))
-    ResourceHelper.safe_delete(@partnership, UserHelper.options(@proposer))
-    ResourceHelper.safe_delete(@partnership, UserHelper.options(@proposed))
+    ResourceHelper.safe_delete(@subscription, @proposer.authentication)
+    ResourceHelper.safe_delete(@partnership, @proposer.authentication)
+    ResourceHelper.safe_delete(@partnership, @proposed.authentication)
     ResourceHelper.safe_delete(@proposer)
     ResourceHelper.safe_delete(@proposed)
   end
@@ -43,28 +43,57 @@ describe 'Entry' do
     @entry.privacy_level = CyberCoach::PrivacyLevel::REGISTERED_USER
   end
 
+  it 'should instantiate itself with preset attributes' do
+    uri = '/pants/'
+    id = 1
+    subscription = CyberCoach::Subscription.new
+    comment = 'those pants are fancy'
+    location = 'in your pants'
+    duration = 123
+    privacy_level = CyberCoach::PrivacyLevel::OWNER
+    pants = 'yes'
+    @entry = CyberCoach::Entry.new(
+      uri: uri,
+      id: id,
+      subscription: subscription,
+      comment: comment,
+      location: location,
+      duration: duration,
+      privacy_level: privacy_level,
+      pants: pants
+    )
+    expect(@entry.uri).to be(uri)
+    expect(@entry.id).to be(id)
+    expect(@entry.subscription).to be(subscription)
+    expect(@entry.comment).to be(comment)
+    expect(@entry.location).to be(location)
+    expect(@entry.duration).to be(duration)
+    expect(@entry.privacy_level).to be(privacy_level)
+    expect { @entry.pants }.to raise_error(NoMethodError)
+  end
+
   it 'should raise an error if it does not exist' do
     @entry.id = 1
-    expect { @entry.read(UserHelper.options(@proposer)) }.to raise_error(CyberCoach::HttpError)
+    expect { @entry.read(@proposer.authentication) }.to raise_error(CyberCoach::HttpError)
   end
 
   describe 'crud' do
     before(:example) do
-      ResourceHelper.safe_delete(@entry, UserHelper.options(@proposer))
+      ResourceHelper.safe_delete(@entry, @proposer.authentication)
     end
 
     after(:example) do
-      ResourceHelper.safe_delete(@entry, UserHelper.options(@proposer))
+      ResourceHelper.safe_delete(@entry, @proposer.authentication)
     end
 
     it 'should create itself' do
-      @entry.create(UserHelper.options(@proposer))
+      @entry.create(@proposer.authentication)
       expect(@entry.id).not_to be_nil
     end
 
     it 'should read itself' do
-      @entry.create(UserHelper.options(@proposer))
-      @entry.read(UserHelper.options(@proposer))
+      @entry.create(@proposer.authentication)
+      @entry.read(@proposer.authentication)
       expect(@entry.id).not_to be_nil
       expect(@entry.uri).not_to be_nil
       expect(@entry.subscription.uri).to eq(@subscription.uri)
@@ -77,19 +106,65 @@ describe 'Entry' do
     end
 
     it 'should update itself' do
-      @entry.create(UserHelper.options(@proposer))
+      @entry.create(@proposer.authentication)
       old_privacy_level = @entry.privacy_level
       new_privacy_level = CyberCoach::PrivacyLevel::EVERYBODY
       @entry.privacy_level = new_privacy_level
-      @entry.update(UserHelper.options(@proposer))
+      @entry.update(@proposer.authentication)
       expect(@entry.privacy_level).not_to eq(old_privacy_level)
       expect(@entry.privacy_level).to eq(new_privacy_level)
     end
 
     it 'should delete itself' do
-      @entry.create(UserHelper.options(@proposer))
-      @entry.delete(UserHelper.options(@proposer))
-      expect { @entry.read(UserHelper.options(@proposer)) }.to raise_error(CyberCoach::HttpError)
+      @entry.create(@proposer.authentication)
+      @entry.delete(@proposer.authentication)
+      expect { @entry.read(@proposer.authentication) }.to raise_error(CyberCoach::HttpError)
+    end
+  end
+
+  describe 'invalidation' do
+    before(:example) do
+      ResourceHelper.safe_delete(@entry, @proposer.authentication)
+    end
+
+    after(:example) do
+      ResourceHelper.safe_delete(@entry, @proposer.authentication)
+    end
+
+    xit 'should not invalidate when creating' do
+      # TODO crap, this impossible to test...
+      id = @entry.id
+      @entry.id = 1234
+      expect(@entry.id).not_to eq(id)
+      expect { @entry.create(@proposer.authentication, false) }.not_to raise_error
+      @entry.id = id
+    end
+
+    it 'should not invalidate when reading' do
+      @entry.create(@proposer.authentication)
+      id = @entry.id
+      @entry.id = 1234
+      expect(@entry.id).not_to eq(id)
+      expect { @entry.read(@proposer.authentication, false) }.not_to raise_error
+      @entry.id = id
+    end
+
+    it 'should not invalidate when updating' do
+      @entry.create(@proposer.authentication)
+      id = @entry.id
+      @entry.id = 1234
+      expect(@entry.id).not_to eq(id)
+      expect { @entry.update(@proposer.authentication, false) }.not_to raise_error
+      @entry.id = id
+    end
+
+    it 'should not invalidate when deleting' do
+      @entry.create(@proposer.authentication)
+      id = @entry.id
+      @entry.id = 1234
+      expect(@entry.id).not_to eq(id)
+      expect { @entry.delete(@proposer.authentication, false) }.not_to raise_error
+      @entry.id = id
     end
   end
-end
+end

data/spec/lib/cybercoach/partnership_spec.rb

@@ -2,8 +2,8 @@ require 'spec_helper'
 
 describe 'Partnership' do
   before(:context) do
-    @proposer = UserHelper.make(6)
-    @proposed = UserHelper.make(7)
+    @proposer = UserHelper.make(8)
+    @proposed = UserHelper.make(9)
     ResourceHelper.safe_delete(@proposer)
     ResourceHelper.safe_delete(@proposed)
     @proposer.create
@@ -22,8 +22,31 @@ describe 'Partnership' do
     @partnership.privacy_level = CyberCoach::PrivacyLevel::REGISTERED_USER
   end
 
+  it 'should instantiate itself with preset attributes' do
+    uri = '/pants/'
+    id = 1
+    proposer = CyberCoach::User.new
+    proposed = CyberCoach::User.new
+    privacy_level = CyberCoach::PrivacyLevel::OWNER
+    pants = 'yes'
+    @partnership = CyberCoach::Partnership.new(
+      uri: uri,
+      id: id,
+      proposer: proposer,
+      proposed: proposed,
+      privacy_level: privacy_level,
+      pants: pants
+    )
+    expect(@partnership.uri).to be(uri)
+    expect(@partnership.id).to be(id)
+    expect(@partnership.proposer).to be(proposer)
+    expect(@partnership.proposed).to be(proposed)
+    expect(@partnership.privacy_level).to be(privacy_level)
+    expect { @partnership.pants }.to raise_error(NoMethodError)
+  end
+
   it 'should raise an error if it does not exist' do
-    expect { @partnership.read(UserHelper.options(@proposer)) }.to raise_error(CyberCoach::HttpError)
+    expect { @partnership.read(@proposer.authentication) }.to raise_error(CyberCoach::HttpError)
   end
 
   it 'should read all' do
@@ -35,21 +58,21 @@ describe 'Partnership' do
 
   describe 'crud' do
     before(:example) do
-      ResourceHelper.safe_delete(@partnership, UserHelper.options(@proposer))
+      ResourceHelper.safe_delete(@partnership, @proposer.authentication)
     end
 
     after(:example) do
-      ResourceHelper.safe_delete(@partnership, UserHelper.options(@proposer))
+      ResourceHelper.safe_delete(@partnership, @proposer.authentication)
     end
 
     it 'should create itself' do
-      @partnership.create(UserHelper.options(@proposer))
+      @partnership.create(@proposer.authentication)
       expect(@partnership.id).not_to be_nil
     end
 
     it 'should read itself' do
-      @partnership.create(UserHelper.options(@proposer))
-      @partnership.read(UserHelper.options(@proposer))
+      @partnership.create(@proposer.authentication)
+      @partnership.read(@proposer.authentication)
       expect(@partnership.id).not_to be_nil
       expect(@partnership.uri).not_to be_nil
       expect(@partnership.proposer.uri).to eq(@proposer.uri)
@@ -61,19 +84,64 @@ describe 'Partnership' do
     end
 
     it 'should update itself' do
-      @partnership.create(UserHelper.options(@proposer))
+      @partnership.create(@proposer.authentication)
       old_privacy_level = @partnership.privacy_level
       new_privacy_level = CyberCoach::PrivacyLevel::EVERYBODY
       @partnership.privacy_level = new_privacy_level
-      @partnership.update(UserHelper.options(@proposer))
+      @partnership.update(@proposer.authentication)
       expect(@partnership.privacy_level).not_to eq(old_privacy_level)
       expect(@partnership.privacy_level).to eq(new_privacy_level)
     end
 
     it 'should delete itself' do
-      @partnership.create(UserHelper.options(@proposer))
-      @partnership.delete(UserHelper.options(@proposer))
-      expect { @partnership.read(UserHelper.options(@proposer)) }.to raise_error(CyberCoach::HttpError)
+      @partnership.create(@proposer.authentication)
+      @partnership.delete(@proposer.authentication)
+      expect { @partnership.read(@proposer.authentication) }.to raise_error(CyberCoach::HttpError)
+    end
+  end
+
+  describe 'invalidation' do
+    before(:example) do
+      ResourceHelper.safe_delete(@partnership, @proposer.authentication)
+    end
+
+    after(:example) do
+      ResourceHelper.safe_delete(@partnership, @proposer.authentication)
+    end
+
+    it 'should not invalidate when creating' do
+      proposer = @partnership.proposer
+      @partnership.proposer = CyberCoach::User.new
+      expect(@partnership.proposer).not_to eq(proposer)
+      expect { @partnership.create(@proposer.authentication, false) }.not_to raise_error
+      @partnership.proposer = proposer
+    end
+
+    it 'should not invalidate when reading' do
+      @partnership.create(@proposer.authentication)
+      proposer = @partnership.proposer
+      @partnership.proposer = CyberCoach::User.new
+      expect(@partnership.proposer).not_to eq(proposer)
+      expect { @partnership.read(@proposer.authentication, false) }.not_to raise_error
+      @partnership.proposer = proposer
+    end
+
+    it 'should not invalidate when updating' do
+      @partnership.create(@proposer.authentication)
+      proposer = @partnership.proposer
+      @partnership.proposer = CyberCoach::User.new
+      expect(@partnership.proposer).not_to eq(proposer)
+      expect { @partnership.update(@proposer.authentication, false) }.not_to raise_error
+      @partnership.proposer = proposer
+    end
+
+    it 'should not invalidate when deleting' do
+      @partnership.create(@proposer.authentication)
+      proposer = @partnership.proposer
+      @partnership.proposer = CyberCoach::User.new
+      expect(@partnership.proposer).not_to eq(proposer)
+      expect { @partnership.delete(@proposer.authentication, false) }.not_to raise_error
+      @partnership.proposer = proposer
     end
   end
-end
+end

data/spec/lib/cybercoach/privacy_level_spec.rb

@@ -12,4 +12,4 @@ describe 'PrivacyLevel' do
   it 'should have an EVERYBODY level' do
     expect(CyberCoach::PrivacyLevel::EVERYBODY).to eq(2)
   end
-end
+end

data/spec/lib/cybercoach/resource_page_spec.rb

@@ -20,6 +20,33 @@ describe 'ResourcePage' do
     end
   end
 
+  it 'should need :type to instantiate' do
+    expect { CyberCoach::ResourcePage.new }.to raise_error(ArgumentError)
+  end
+
+  it 'should instantiate itself with preset attributes' do
+    uri = '/pants/'
+    type = CyberCoach::User
+    start = 1
+    end_ = 6
+    size = 5
+    pants = 'yes'
+    @page = CyberCoach::ResourcePage.new(
+      uri: uri,
+      type: type,
+      start: start,
+      end: end_,
+      size: size,
+      pants: pants
+    )
+    expect(@page.uri).to be(uri)
+    expect(@page.type).to be(type)
+    expect(@page.start).to be(start)
+    expect(@page.end).to be(end_)
+    expect(@page.size).to be(size)
+    expect { @page.pants }.to raise_error(NoMethodError)
+  end
+
   it 'should read itself' do
     @page.start = 1
     @page.size = 2
@@ -29,8 +56,20 @@ describe 'ResourcePage' do
     expect(@page.end).to eq(3)
   end
 
+  it 'should not invalidate when reading' do
+    start = @page.start
+    size = @page.size
+    @page.start = 5
+    @page.size = 6
+    expect(@page.size).not_to eq(size)
+    expect(@page.start).not_to eq(start)
+    @page.read({}, false)
+    expect(@page.size).to eq(size)
+    expect(@page.start).to eq(start)
+  end
+
   it 'should be able to navigate between pages' do
-    expect{@page.previous}.to raise_error(CyberCoach::ResourcePage::NoPreviousPageError)
+    expect { @page.previous }.to raise_error(CyberCoach::ResourcePage::NoPreviousPageError)
     next_page = @page.next
     expect(next_page.resources).not_to be_empty
     expect(next_page.start).to eq(@page.end)
@@ -41,4 +80,4 @@ describe 'ResourcePage' do
     next_previous_page = next_page.previous
     expect(next_previous_page.resources[0].uri).to eq(@page.resources[0].uri)
   end
-end
+end

data/spec/lib/cybercoach/settings_spec.rb

@@ -7,4 +7,4 @@ describe 'Settings' do
   it 'should have a server URI' do
     expect(CyberCoach::Settings::SERVER_URI).not_to be_nil
   end
-end
+end

data/spec/lib/cybercoach/sport_spec.rb

@@ -5,6 +5,26 @@ describe 'Sport' do
     @sport = CyberCoach::Sport.new
   end
 
+  it 'should instantiate itself with preset attributes' do
+    uri = '/pants/'
+    id = 1
+    name = 'pants'
+    description = 'very fancy'
+    pants = 'yes'
+    @sport = CyberCoach::Sport.new(
+      uri: uri,
+      id: id,
+      name: name,
+      description: description,
+      pants: pants
+    )
+    expect(@sport.uri).to be(uri)
+    expect(@sport.id).to be(id)
+    expect(@sport.name).to be(name)
+    expect(@sport.description).to be(description)
+    expect { @sport.pants }.to raise_error(NoMethodError)
+  end
+
   it 'should read itself' do
     @sport.name = 'Running'
     @sport.read
@@ -15,15 +35,25 @@ describe 'Sport' do
     expect(@sport.subscriptions).not_to be_empty
   end
 
+  it 'should not invalidate when reading' do
+    @sport.name = 'Running'
+    @sport.read
+    name = @sport.name
+    @sport.name = 'notTheName'
+    expect(@sport.name).not_to eq(name)
+    expect { @sport.read({}, false) }.not_to raise_error
+    @sport.name = name
+  end
+
   it 'should raise an error if it does not exist' do
     @sport.name = 'Pants'
-    expect{@sport.read}.to raise_error(CyberCoach::HttpError)
+    expect { @sport.read }.to raise_error(CyberCoach::HttpError)
   end
 
   it 'should read all' do
     sports = CyberCoach::Sport.read_all
     expect(sports.resources.size).to eq(4)
-    expect{sports.next}.to raise_error(CyberCoach::ResourcePage::NoNextPageError)
-    expect{sports.previous}.to raise_error(CyberCoach::ResourcePage::NoPreviousPageError)
+    expect { sports.next }.to raise_error(CyberCoach::ResourcePage::NoNextPageError)
+    expect { sports.previous }.to raise_error(CyberCoach::ResourcePage::NoPreviousPageError)
   end
-end
+end