librarian 0.1.1 → 0.1.2

data/spec/unit/environment/runtime_cache_spec.rb

@@ -0,0 +1,73 @@
+require "librarian/environment/runtime_cache"
+
+module Librarian
+  class Environment
+    describe RuntimeCache do
+
+      let(:rtc) { described_class.new }
+      let(:key) { ["brah", "nick"] }
+      let(:key_x) { ["brah", "phar"] }
+      let(:key_y) { ["rost", "phar"] }
+
+      def triple(keypair)
+        [rtc.include?(*keypair), rtc.get(*keypair), rtc.memo(*keypair){yield}]
+      end
+
+      context "originally" do
+        specify { expect(triple(key){9}).to eql([false, nil, 9]) }
+      end
+
+      context "after put" do
+        before { rtc.put(*key){6} }
+
+        specify { expect(triple(key){9}).to eql([true, 6, 6]) }
+        specify { expect(triple(key_x){9}).to eql([false, nil, 9]) }
+        specify { expect(triple(key_y){9}).to eql([false, nil, 9]) }
+      end
+
+      context "after put then delete" do
+        before { rtc.put(*key){6} }
+        before { rtc.delete *key }
+
+        specify { expect(triple(key){9}).to eql([false, nil, 9]) }
+        specify { expect(triple(key_x){9}).to eql([false, nil, 9]) }
+        specify { expect(triple(key_y){9}).to eql([false, nil, 9]) }
+      end
+
+      context "after memo" do
+        before { rtc.memo(*key){6} }
+
+        specify { expect(triple(key){9}).to eql([true, 6, 6]) }
+        specify { expect(triple(key_x){9}).to eql([false, nil, 9]) }
+        specify { expect(triple(key_y){9}).to eql([false, nil, 9]) }
+      end
+
+      context "after memo then delete" do
+        before { rtc.memo(*key){6} }
+        before { rtc.delete *key }
+
+        specify { expect(triple(key){9}).to eql([false, nil, 9]) }
+        specify { expect(triple(key_x){9}).to eql([false, nil, 9]) }
+        specify { expect(triple(key_y){9}).to eql([false, nil, 9]) }
+      end
+
+      context "with keyspace wrapper" do
+        let(:krtc) { rtc.keyspace("brah") }
+        let(:key) { "nick" }
+        let(:key_x) { "phar" }
+
+        def triple(keypair)
+          [krtc.include?(key), krtc.get(key), krtc.memo(key){yield}]
+        end
+
+        context "after put" do
+          before { krtc.put(key){6} }
+
+          specify { expect(triple(key){9}).to eql([true, 6, 6]) }
+        end
+
+      end
+
+    end
+  end
+end

data/spec/unit/environment_spec.rb

@@ -9,15 +9,15 @@ module Librarian
     let(:env) { described_class.new }
 
     describe "#adapter_module" do
-      specify { env.adapter_module.should be nil }
+      specify { expect(env.adapter_module).to be nil }
     end
 
     describe "#adapter_name" do
-      specify { env.adapter_name.should be nil }
+      specify { expect(env.adapter_name).to be nil }
     end
 
     describe "#adapter_version" do
-      specify { env.adapter_version.should be nil }
+      specify { expect(env.adapter_version).to be nil }
     end
 
     describe "computing the home" do
@@ -27,7 +27,7 @@ module Librarian
 
         it "finds the home" do
           env.stub(:adapter_name).and_return("cat")
-          env.config_db.underlying_home.to_s.should == "/path/to/home"
+          expect(env.config_db.underlying_home.to_s).to eq "/path/to/home"
         end
       end
 
@@ -37,7 +37,7 @@ module Librarian
 
         it "finds the home" do
           env.stub(:adapter_name).and_return("cat")
-          env.config_db.underlying_home.to_s.should == real_home
+          expect(env.config_db.underlying_home.to_s).to eq real_home
         end
       end
 
@@ -49,7 +49,7 @@ module Librarian
         with_env  "http_proxy" => nil
 
         it "should have a nil http proxy uri" do
-          env.http_proxy_uri.should be_nil
+          expect(env.http_proxy_uri).to be_nil
         end
       end
 
@@ -57,19 +57,19 @@ module Librarian
         with_env  "http_proxy" => "admin:secret@example.com"
 
         it "should have the expcted http proxy uri" do
-          env.http_proxy_uri.should == URI("http://admin:secret@example.com")
+          expect(env.http_proxy_uri).to eq URI("http://admin:secret@example.com")
         end
 
         it "should have the expected host" do
-          env.http_proxy_uri.host.should == "example.com"
+          expect(env.http_proxy_uri.host).to eq "example.com"
         end
 
         it "should have the expected user" do
-          env.http_proxy_uri.user.should == "admin"
+          expect(env.http_proxy_uri.user).to eq "admin"
         end
 
         it "should have the expected password" do
-          env.http_proxy_uri.password.should == "secret"
+          expect(env.http_proxy_uri.password).to eq "secret"
         end
       end
 
@@ -79,7 +79,7 @@ module Librarian
                   "http_proxy_pass" => "secret"
 
         it "should have the expcted http proxy uri" do
-          env.http_proxy_uri.should == URI("http://admin:secret@example.com")
+          expect(env.http_proxy_uri).to eq URI("http://admin:secret@example.com")
         end
       end
 
@@ -91,11 +91,11 @@ module Librarian
         with_env  "http_proxy" => nil
 
         it "should have the normal class" do
-          env.net_http_class(proxied_host).should be Net::HTTP
+          expect(env.net_http_class(proxied_host)).to be Net::HTTP
         end
 
         it "should not be marked as a proxy class" do
-          env.net_http_class(proxied_host).should_not be_proxy_class
+          expect(env.net_http_class(proxied_host)).to_not be_proxy_class
         end
       end
 
@@ -103,18 +103,18 @@ module Librarian
         with_env  "http_proxy" => "admin:secret@example.com"
 
         it "should not by marked as a proxy class for localhost" do
-          env.net_http_class('localhost').should_not be_proxy_class
+          expect(env.net_http_class('localhost')).to_not be_proxy_class
         end
         it "should not have the normal class" do
-          env.net_http_class(proxied_host).should_not be Net::HTTP
+          expect(env.net_http_class(proxied_host)).to_not be Net::HTTP
         end
 
         it "should have a subclass the normal class" do
-          env.net_http_class(proxied_host).should < Net::HTTP
+          expect(env.net_http_class(proxied_host)).to be < Net::HTTP
         end
 
         it "should be marked as a proxy class" do
-          env.net_http_class(proxied_host).should be_proxy_class
+          expect(env.net_http_class(proxied_host)).to be_proxy_class
         end
 
         it "should have the expected proxy attributes" do
@@ -132,7 +132,7 @@ module Librarian
             "pass" => http.proxy_pass,
           }
 
-          actual_attributes.should == expected_attributes
+          expect(actual_attributes).to eq expected_attributes
         end
 
       end
@@ -145,11 +145,11 @@ module Librarian
           let(:proxied_host) { "noproxy.com" }
 
           it "should have the normal class" do
-            env.net_http_class(proxied_host).should be Net::HTTP
+            expect(env.net_http_class(proxied_host)).to be Net::HTTP
           end
 
           it "should not be marked as a proxy class" do
-            env.net_http_class(proxied_host).should_not be_proxy_class
+            expect(env.net_http_class(proxied_host)).to_not be_proxy_class
           end
         end
 
@@ -157,11 +157,11 @@ module Librarian
           let(:proxied_host) { "www.noproxy.com" }
 
           it "should have the normal class" do
-            env.net_http_class(proxied_host).should be Net::HTTP
+            expect(env.net_http_class(proxied_host)).to be Net::HTTP
           end
 
           it "should not be marked as a proxy class" do
-            env.net_http_class(proxied_host).should_not be_proxy_class
+            expect(env.net_http_class(proxied_host)).to_not be_proxy_class
           end
         end
 
@@ -169,11 +169,11 @@ module Librarian
           let(:proxied_host) { "localhost" }
 
           it "should have the normal class" do
-            env.net_http_class(proxied_host).should be Net::HTTP
+            expect(env.net_http_class(proxied_host)).to be Net::HTTP
           end
 
           it "should not be marked as a proxy class" do
-            env.net_http_class(proxied_host).should_not be_proxy_class
+            expect(env.net_http_class(proxied_host)).to_not be_proxy_class
           end
         end
 
@@ -181,11 +181,11 @@ module Librarian
           let(:proxied_host) { "127.0.0.1" }
 
           it "should have the normal class" do
-            env.net_http_class(proxied_host).should be Net::HTTP
+            expect(env.net_http_class(proxied_host)).to be Net::HTTP
           end
 
           it "should not be marked as a proxy class" do
-            env.net_http_class(proxied_host).should_not be_proxy_class
+            expect(env.net_http_class(proxied_host)).to_not be_proxy_class
           end
         end
 
@@ -193,11 +193,11 @@ module Librarian
           let(:proxied_host) { "www.example.com" }
 
           it "should have a subclass the normal class" do
-            env.net_http_class(proxied_host).should < Net::HTTP
+            expect(env.net_http_class(proxied_host)).to be < Net::HTTP
           end
 
           it "should be marked as a proxy class" do
-            env.net_http_class(proxied_host).should be_proxy_class
+            expect(env.net_http_class(proxied_host)).to be_proxy_class
           end
         end
 

data/spec/unit/lockfile/parser_spec.rb

@@ -22,11 +22,11 @@ module Librarian
       end
 
       it "should give an empty list of dependencies" do
-        resolution.dependencies.should be_empty
+        expect(resolution.dependencies).to be_empty
       end
 
       it "should give an empty list of manifests" do
-        resolution.manifests.should be_empty
+        expect(resolution.manifests).to be_empty
       end
     end
 
@@ -45,56 +45,56 @@ module Librarian
       end
 
       it "should give a list of one dependency" do
-        resolution.should have(1).dependencies
+        expect(resolution).to have(1).dependencies
       end
 
       it "should give a dependency with the expected name" do
         dependency = resolution.dependencies.first
 
-        dependency.name.should == "jelly"
+        expect(dependency.name).to eq "jelly"
       end
 
       it "should give a dependency with the expected requirement" do
         dependency = resolution.dependencies.first
 
         # Note: it must be this order because this order is lexicographically sorted.
-        dependency.requirement.to_s.should == "!= 1.2.6, ~> 1.1"
+        expect(dependency.requirement.to_s).to eq "!= 1.2.6, ~> 1.1"
       end
 
       it "should give a dependency wth the expected source" do
         dependency = resolution.dependencies.first
         source = dependency.source
 
-        source.name.should == "source-a"
+        expect(source.name).to eq "source-a"
       end
 
       it "should give a list of one manifest" do
-        resolution.should have(1).manifests
+        expect(resolution).to have(1).manifests
       end
 
       it "should give a manifest with the expected name" do
         manifest = resolution.manifests.first
 
-        manifest.name.should == "jelly"
+        expect(manifest.name).to eq "jelly"
       end
 
       it "should give a manifest with the expected version" do
         manifest = resolution.manifests.first
 
-        manifest.version.to_s.should == "1.3.5"
+        expect(manifest.version.to_s).to eq "1.3.5"
       end
 
       it "should give a manifest with no dependencies" do
         manifest = resolution.manifests.first
 
-        manifest.dependencies.should be_empty
+        expect(manifest.dependencies).to be_empty
       end
 
       it "should give a manifest with the expected source" do
         manifest = resolution.manifests.first
         source = manifest.source
 
-        source.name.should == "source-a"
+        expect(source.name).to eq "source-a"
       end
 
       it "should give the dependency and the manifest the same source instance" do
@@ -104,7 +104,7 @@ module Librarian
         dependency_source = dependency.source
         manifest_source = manifest.source
 
-        manifest_source.should be dependency_source
+        expect(manifest_source).to be dependency_source
       end
     end
 
@@ -125,36 +125,36 @@ module Librarian
       end
 
       it "should give a list of one dependency" do
-        resolution.should have(1).dependencies
+        expect(resolution).to have(1).dependencies
       end
 
       it "should have the expected dependency" do
         dependency = resolution.dependencies.first
 
-        dependency.name.should == "jelly"
+        expect(dependency.name).to eq "jelly"
       end
 
       it "should give a list of all the manifests" do
-        resolution.should have(2).manifests
+        expect(resolution).to have(2).manifests
       end
 
       it "should include all the expected manifests" do
         manifests = ManifestSet.new(resolution.manifests)
 
-        manifests.to_hash.keys.should =~ %w(butter jelly)
+        expect(manifests.to_hash.keys).to match_array( %w(butter jelly) )
       end
 
       it "should have an internally consistent set of manifests" do
         manifests = ManifestSet.new(resolution.manifests)
 
-        manifests.should be_consistent
+        expect(manifests).to be_consistent
       end
 
       it "should have an externally consistent set of manifests" do
         dependencies = resolution.dependencies
         manifests = ManifestSet.new(resolution.manifests)
 
-        manifests.should be_in_compliance_with dependencies
+        expect(manifests).to be_in_compliance_with dependencies
       end
     end
 

data/spec/unit/lockfile_spec.rb

@@ -39,7 +39,7 @@ module Librarian
 
       context "just saving" do
         it "should return the lockfile text" do
-          lockfile_text.should_not be_nil
+          expect(lockfile_text).to_not be_nil
         end
       end
 
@@ -47,7 +47,7 @@ module Librarian
         let(:reloaded_resolution) { lockfile.load(lockfile_text) }
 
         it "should have the expected manifests" do
-          reloaded_resolution.manifests.count.should == resolution.manifests.count
+          expect(reloaded_resolution.manifests.count).to eq resolution.manifests.count
         end
       end
 
@@ -56,7 +56,7 @@ module Librarian
         let(:bounced_lockfile_text) { lockfile.save(bounced_resolution) }
 
         it "should return the same lockfile text after bouncing as before bouncing" do
-          bounced_lockfile_text.should == lockfile_text
+          expect(bounced_lockfile_text).to eq lockfile_text
         end
       end
     end

data/spec/unit/manifest/version_spec.rb

@@ -0,0 +1,11 @@
+require "librarian/manifest"
+
+describe Librarian::Manifest::Version do
+
+  describe "#inspect" do
+    subject(:version) { described_class.new("3.2.1") }
+
+    specify { expect(version.inspect).to eq "#<Librarian::Manifest::Version 3.2.1>" }
+  end
+
+end

data/spec/unit/manifest_set_spec.rb

@@ -15,11 +15,11 @@ module Librarian
         let(:set) { described_class.new(array) }
 
         it "should give back the array" do
-          set.to_a.should =~ array
+          expect(set.to_a).to match_array( array )
         end
 
         it "should give back the hash" do
-          set.to_hash.should == hash
+          expect(set.to_hash).to eq hash
         end
       end
 
@@ -27,11 +27,11 @@ module Librarian
         let(:set) { described_class.new(hash) }
 
         it "should give back the array" do
-          set.to_a.should =~ array
+          expect(set.to_a).to match_array( array )
         end
 
         it "should give back the hash" do
-          set.to_hash.should == hash
+          expect(set.to_hash).to eq hash
         end
       end
     end
@@ -48,19 +48,19 @@ module Librarian
       it "should not do anything when given no names" do
         set.shallow_strip!([])
 
-        set.to_a.should =~ [jelly, butter, jam]
+        expect(set.to_a).to match_array( [jelly, butter, jam] )
       end
 
       it "should remove only the named elements" do
         set.shallow_strip!(["butter", "jam"])
 
-        set.to_a.should =~ [jelly]
+        expect(set.to_a).to match_array( [jelly] )
       end
 
       it "should allow removing all the elements" do
         set.shallow_strip!(["jelly", "butter", "jam"])
 
-        set.to_a.should =~ []
+        expect(set.to_a).to match_array( [] )
       end
     end
 
@@ -76,19 +76,19 @@ module Librarian
       it "should empty the set when given no names" do
         set.shallow_keep!([])
 
-        set.to_a.should =~ []
+        expect(set.to_a).to match_array( [] )
       end
 
       it "should keep only the named elements" do
         set.shallow_keep!(["butter", "jam"])
 
-        set.to_a.should =~ [butter, jam]
+        expect(set.to_a).to match_array( [butter, jam] )
       end
 
       it "should allow keeping all the elements" do
         set.shallow_keep!(["jelly", "butter", "jam"])
 
-        set.to_a.should =~ [jelly, butter, jam]
+        expect(set.to_a).to match_array( [jelly, butter, jam] )
       end
     end
 
@@ -117,31 +117,31 @@ module Librarian
       it "should not do anything when given no names" do
         set.deep_strip!([])
 
-        set.to_a.should =~ [a, b, c, d, e, f, g, h]
+        expect(set.to_a).to match_array( [a, b, c, d, e, f, g, h] )
       end
 
       it "should remove just the named elements if they have no dependencies" do
         set.deep_strip!(["c", "h"])
 
-        set.to_a.should =~ [a, b, d, e, f, g]
+        expect(set.to_a).to match_array( [a, b, d, e, f, g] )
       end
 
       it "should remove the named elements and all their dependencies" do
         set.deep_strip!(["b"])
 
-        set.to_a.should =~ [a, e, f, g, h]
+        expect(set.to_a).to match_array( [a, e, f, g, h] )
       end
 
       it "should remove an entire tree of dependencies" do
         set.deep_strip!(["e"])
 
-        set.to_a.should =~ [a, b, c, d]
+        expect(set.to_a).to match_array( [a, b, c, d] )
       end
 
       it "should allow removing all the elements" do
         set.deep_strip!(["a", "e"])
 
-        set.to_a.should =~ []
+        expect(set.to_a).to match_array( [] )
       end
     end
 
@@ -170,31 +170,31 @@ module Librarian
       it "should remove all the elements when given no names" do
         set.deep_keep!([])
 
-        set.to_a.should =~ []
+        expect(set.to_a).to match_array( [] )
       end
 
       it "should keep just the named elements if they have no dependencies" do
         set.deep_keep!(["c", "h"])
 
-        set.to_a.should =~ [c, h]
+        expect(set.to_a).to match_array( [c, h] )
       end
 
       it "should keep the named elements and all their dependencies" do
         set.deep_keep!(["b"])
 
-        set.to_a.should =~ [b, c, d]
+        expect(set.to_a).to match_array( [b, c, d] )
       end
 
       it "should keep an entire tree of dependencies" do
         set.deep_keep!(["e"])
 
-        set.to_a.should =~ [e, f, g, h]
+        expect(set.to_a).to match_array( [e, f, g, h] )
       end
 
       it "should allow keeping all the elements" do
         set.deep_keep!(["a", "e"])
 
-        set.to_a.should =~ [a, b, c, d, e, f, g, h]
+        expect(set.to_a).to match_array( [a, b, c, d, e, f, g, h] )
       end
     end