librarianp 0.1.2

data/spec/unit/dsl_spec.rb

@@ -0,0 +1,173 @@
+require 'librarian'
+require 'librarian/mock'
+
+module Librarian
+  module Mock
+
+    describe Dsl do
+
+      let(:env) { Environment.new }
+
+      context "a single source and a single dependency with a blank name" do
+        it "should not not run with a blank name" do
+          expect do
+            env.dsl do
+              src 'source-1'
+              dep ''
+            end
+          end.to raise_error(ArgumentError, %{name ("") must be sensible})
+        end
+      end
+
+      context "a simple specfile - a single source, a single dependency, no transitive dependencies" do
+
+        it "should run with a hash source" do
+          spec = env.dsl do
+            dep 'dependency-1',
+              :src => 'source-1'
+          end
+          expect(spec.dependencies).to_not be_empty
+          expect(spec.dependencies.first.name).to eq 'dependency-1'
+          expect(spec.dependencies.first.source.name).to eq 'source-1'
+          expect(spec.sources).to be_empty
+        end
+
+        it "should run with a shortcut source" do
+          spec = env.dsl do
+            dep 'dependency-1',
+              :source => :a
+          end
+          expect(spec.dependencies).to_not be_empty
+          expect(spec.dependencies.first.name).to eq 'dependency-1'
+          expect(spec.dependencies.first.source.name).to eq 'source-a'
+          expect(spec.sources).to be_empty
+        end
+
+        it "should run with a block hash source" do
+          spec = env.dsl do
+            source :src => 'source-1' do
+              dep 'dependency-1'
+            end
+          end
+          expect(spec.dependencies).to_not be_empty
+          expect(spec.dependencies.first.name).to eq 'dependency-1'
+          expect(spec.dependencies.first.source.name).to eq 'source-1'
+          expect(spec.sources).to be_empty
+        end
+
+        it "should run with a block named source" do
+          spec = env.dsl do
+            src 'source-1' do
+              dep 'dependency-1'
+            end
+          end
+          expect(spec.dependencies).to_not be_empty
+          expect(spec.dependencies.first.name).to eq 'dependency-1'
+          expect(spec.dependencies.first.source.name).to eq 'source-1'
+          expect(spec.sources).to be_empty
+        end
+
+        it "should run with a default hash source" do
+          spec = env.dsl do
+            source :src => 'source-1'
+            dep 'dependency-1'
+          end
+          expect(spec.dependencies).to_not be_empty
+          expect(spec.dependencies.first.name).to eq 'dependency-1'
+          expect(spec.dependencies.first.source.name).to eq 'source-1'
+          expect(spec.sources).to_not be_empty
+          expect(spec.dependencies.first.source).to eq spec.sources.first
+        end
+
+        it "should run with a default named source" do
+          spec = env.dsl do
+            src 'source-1'
+            dep 'dependency-1'
+          end
+          expect(spec.dependencies).to_not be_empty
+          expect(spec.dependencies.first.name).to eq 'dependency-1'
+          expect(spec.dependencies.first.source.name).to eq 'source-1'
+          expect(spec.sources).to_not be_empty
+          expect(spec.dependencies.first.source).to eq spec.sources.first
+        end
+
+        it "should run with a default shortcut source" do
+          spec = env.dsl do
+            source :a
+            dep 'dependency-1'
+          end
+          expect(spec.dependencies).to_not be_empty
+          expect(spec.dependencies.first.name).to eq 'dependency-1'
+          expect(spec.dependencies.first.source.name).to eq 'source-a'
+          expect(spec.sources).to_not be_empty
+          expect(spec.dependencies.first.source).to eq spec.sources.first
+        end
+
+        it "should run with a shortcut source hash definition" do
+          spec = env.dsl do
+            source :b, :src => 'source-b'
+            dep 'dependency-1', :source => :b
+          end
+          expect(spec.dependencies).to_not be_empty
+          expect(spec.dependencies.first.name).to eq 'dependency-1'
+          expect(spec.dependencies.first.source.name).to eq 'source-b'
+          expect(spec.sources).to be_empty
+        end
+
+        it "should run with a shortcut source block definition" do
+          spec = env.dsl do
+            source :b, proc { src 'source-b' }
+            dep 'dependency-1', :source => :b
+          end
+          expect(spec.dependencies).to_not be_empty
+          expect(spec.dependencies.first.name).to eq 'dependency-1'
+          expect(spec.dependencies.first.source.name).to eq 'source-b'
+          expect(spec.sources).to be_empty
+        end
+
+        it "should run with a default shortcut source hash definition" do
+          spec = env.dsl do
+            source :b, :src => 'source-b'
+            source :b
+            dep 'dependency-1'
+          end
+          expect(spec.dependencies).to_not be_empty
+          expect(spec.dependencies.first.name).to eq 'dependency-1'
+          expect(spec.dependencies.first.source.name).to eq 'source-b'
+          expect(spec.sources).to_not be_empty
+          expect(spec.sources.first.name).to eq 'source-b'
+        end
+
+        it "should run with a default shortcut source block definition" do
+          spec = env.dsl do
+            source :b, proc { src 'source-b' }
+            source :b
+            dep 'dependency-1'
+          end
+          expect(spec.dependencies).to_not be_empty
+          expect(spec.dependencies.first.name).to eq 'dependency-1'
+          expect(spec.dependencies.first.source.name).to eq 'source-b'
+          expect(spec.sources).to_not be_empty
+          expect(spec.sources.first.name).to eq 'source-b'
+        end
+
+      end
+
+      context "validating source options" do
+
+        it "should raise when given unrecognized optiosn options" do
+          expect do
+            env.dsl do
+              dep 'dependency-1',
+                :src => 'source-1',
+                :huh => 'yikes'
+            end
+          end.to raise_error(Error, %{unrecognized options: huh})
+        end
+
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,209 @@
+require "librarian/environment"
+
+require "support/with_env_macro"
+
+module Librarian
+  describe Environment do
+    include ::Support::WithEnvMacro
+
+    let(:env) { described_class.new }
+
+    describe "#adapter_module" do
+      specify { expect(env.adapter_module).to be nil }
+    end
+
+    describe "#adapter_name" do
+      specify { expect(env.adapter_name).to be nil }
+    end
+
+    describe "#adapter_version" do
+      specify { expect(env.adapter_version).to be nil }
+    end
+
+    describe "computing the home" do
+
+      context "with the HOME env var" do
+        with_env "HOME" => "/path/to/home"
+
+        it "finds the home" do
+          env.stub(:adapter_name).and_return("cat")
+          expect(env.config_db.underlying_home.to_s).to eq "/path/to/home"
+        end
+      end
+
+      context "without the HOME env var" do
+        let!(:real_home) { File.expand_path("~") }
+        with_env "HOME" => nil
+
+        it "finds the home" do
+          env.stub(:adapter_name).and_return("cat")
+          expect(env.config_db.underlying_home.to_s).to eq real_home
+        end
+      end
+
+    end
+
+    describe "#http_proxy_uri" do
+
+      context "sanity" do
+        with_env  "http_proxy" => nil
+
+        it "should have a nil http proxy uri" do
+          expect(env.http_proxy_uri).to be_nil
+        end
+      end
+
+      context "with a complex proxy" do
+        with_env  "http_proxy" => "admin:secret@example.com"
+
+        it "should have the expcted http proxy uri" do
+          expect(env.http_proxy_uri).to eq URI("http://admin:secret@example.com")
+        end
+
+        it "should have the expected host" do
+          expect(env.http_proxy_uri.host).to eq "example.com"
+        end
+
+        it "should have the expected user" do
+          expect(env.http_proxy_uri.user).to eq "admin"
+        end
+
+        it "should have the expected password" do
+          expect(env.http_proxy_uri.password).to eq "secret"
+        end
+      end
+
+      context "with a split proxy" do
+        with_env  "http_proxy" => "example.com",
+                  "http_proxy_user" => "admin",
+                  "http_proxy_pass" => "secret"
+
+        it "should have the expcted http proxy uri" do
+          expect(env.http_proxy_uri).to eq URI("http://admin:secret@example.com")
+        end
+      end
+
+    end
+
+    describe "#net_http_class" do
+      let(:proxied_host) { "www.example.com" }
+      context "sanity" do
+        with_env  "http_proxy" => nil
+
+        it "should have the normal class" do
+          expect(env.net_http_class(proxied_host)).to be Net::HTTP
+        end
+
+        it "should not be marked as a proxy class" do
+          expect(env.net_http_class(proxied_host)).to_not be_proxy_class
+        end
+      end
+
+      context "with a complex proxy" do
+        with_env  "http_proxy" => "admin:secret@example.com"
+
+        it "should not by marked as a proxy class for localhost" do
+          expect(env.net_http_class('localhost')).to_not be_proxy_class
+        end
+        it "should not have the normal class" do
+          expect(env.net_http_class(proxied_host)).to_not be Net::HTTP
+        end
+
+        it "should have a subclass the normal class" do
+          expect(env.net_http_class(proxied_host)).to be < Net::HTTP
+        end
+
+        it "should be marked as a proxy class" do
+          expect(env.net_http_class(proxied_host)).to be_proxy_class
+        end
+
+        it "should have the expected proxy attributes" do
+          http = env.net_http_class(proxied_host).new("www.kernel.org")
+          expected_attributes = {
+            "host" => env.http_proxy_uri.host,
+            "port" => env.http_proxy_uri.port,
+            "user" => env.http_proxy_uri.user,
+            "pass" => env.http_proxy_uri.password
+          }
+          actual_attributes = {
+            "host" => http.proxy_address,
+            "port" => http.proxy_port,
+            "user" => http.proxy_user,
+            "pass" => http.proxy_pass,
+          }
+
+          expect(actual_attributes).to eq expected_attributes
+        end
+
+      end
+
+      context "with an excluded host" do
+        with_env  "http_proxy" => "admin:secret@example.com",
+                  "no_proxy" => "no.proxy.com, noproxy.com"
+
+        context "with an exact match" do
+          let(:proxied_host) { "noproxy.com" }
+
+          it "should have the normal class" do
+            expect(env.net_http_class(proxied_host)).to be Net::HTTP
+          end
+
+          it "should not be marked as a proxy class" do
+            expect(env.net_http_class(proxied_host)).to_not be_proxy_class
+          end
+        end
+
+        context "with a subdomain match" do
+          let(:proxied_host) { "www.noproxy.com" }
+
+          it "should have the normal class" do
+            expect(env.net_http_class(proxied_host)).to be Net::HTTP
+          end
+
+          it "should not be marked as a proxy class" do
+            expect(env.net_http_class(proxied_host)).to_not be_proxy_class
+          end
+        end
+
+        context "with localhost" do
+          let(:proxied_host) { "localhost" }
+
+          it "should have the normal class" do
+            expect(env.net_http_class(proxied_host)).to be Net::HTTP
+          end
+
+          it "should not be marked as a proxy class" do
+            expect(env.net_http_class(proxied_host)).to_not be_proxy_class
+          end
+        end
+
+        context "with 127.0.0.1" do
+          let(:proxied_host) { "127.0.0.1" }
+
+          it "should have the normal class" do
+            expect(env.net_http_class(proxied_host)).to be Net::HTTP
+          end
+
+          it "should not be marked as a proxy class" do
+            expect(env.net_http_class(proxied_host)).to_not be_proxy_class
+          end
+        end
+
+        context "with a mismatch" do
+          let(:proxied_host) { "www.example.com" }
+
+          it "should have a subclass the normal class" do
+            expect(env.net_http_class(proxied_host)).to be < Net::HTTP
+          end
+
+          it "should be marked as a proxy class" do
+            expect(env.net_http_class(proxied_host)).to be_proxy_class
+          end
+        end
+
+      end
+
+    end
+
+  end
+end

data/spec/unit/lockfile/parser_spec.rb

@@ -0,0 +1,162 @@
+require "librarian/helpers"
+require "librarian/lockfile/parser"
+require "librarian/mock"
+
+module Librarian
+  describe Lockfile::Parser do
+
+    let(:env) { Mock::Environment.new }
+    let(:parser) { described_class.new(env) }
+    let(:resolution) { parser.parse(lockfile) }
+
+    context "a mock lockfile with one source and no dependencies" do
+      let(:lockfile) do
+        Helpers.strip_heredoc <<-LOCKFILE
+          MOCK
+            remote: source-a
+            specs:
+
+          DEPENDENCIES
+
+        LOCKFILE
+      end
+
+      it "should give an empty list of dependencies" do
+        expect(resolution.dependencies).to be_empty
+      end
+
+      it "should give an empty list of manifests" do
+        expect(resolution.manifests).to be_empty
+      end
+    end
+
+    context "a mock lockfile with one source and one dependency" do
+      let(:lockfile) do
+        Helpers.strip_heredoc <<-LOCKFILE
+          MOCK
+            remote: source-a
+            specs:
+              jelly (1.3.5)
+
+          DEPENDENCIES
+            jelly (!= 1.2.6, ~> 1.1)
+
+        LOCKFILE
+      end
+
+      it "should give a list of one dependency" do
+        expect(resolution).to have(1).dependencies
+      end
+
+      it "should give a dependency with the expected name" do
+        dependency = resolution.dependencies.first
+
+        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.
+        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
+
+        expect(source.name).to eq "source-a"
+      end
+
+      it "should give a list of one manifest" do
+        expect(resolution).to have(1).manifests
+      end
+
+      it "should give a manifest with the expected name" do
+        manifest = resolution.manifests.first
+
+        expect(manifest.name).to eq "jelly"
+      end
+
+      it "should give a manifest with the expected version" do
+        manifest = resolution.manifests.first
+
+        expect(manifest.version.to_s).to eq "1.3.5"
+      end
+
+      it "should give a manifest with no dependencies" do
+        manifest = resolution.manifests.first
+
+        expect(manifest.dependencies).to be_empty
+      end
+
+      it "should give a manifest with the expected source" do
+        manifest = resolution.manifests.first
+        source = manifest.source
+
+        expect(source.name).to eq "source-a"
+      end
+
+      it "should give the dependency and the manifest the same source instance" do
+        dependency = resolution.dependencies.first
+        manifest = resolution.manifests.first
+
+        dependency_source = dependency.source
+        manifest_source = manifest.source
+
+        expect(manifest_source).to be dependency_source
+      end
+    end
+
+    context "a mock lockfile with one source and a complex dependency" do
+      let(:lockfile) do
+        Helpers.strip_heredoc <<-LOCKFILE
+          MOCK
+            remote: source-a
+            specs:
+              butter (2.5.3)
+              jelly (1.3.5)
+                butter (< 3, >= 1.1)
+
+          DEPENDENCIES
+            jelly (!= 1.2.6, ~> 1.1)
+
+        LOCKFILE
+      end
+
+      it "should give a list of one dependency" do
+        expect(resolution).to have(1).dependencies
+      end
+
+      it "should have the expected dependency" do
+        dependency = resolution.dependencies.first
+
+        expect(dependency.name).to eq "jelly"
+      end
+
+      it "should give a list of all the manifests" do
+        expect(resolution).to have(2).manifests
+      end
+
+      it "should include all the expected manifests" do
+        manifests = ManifestSet.new(resolution.manifests)
+
+        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)
+
+        expect(manifests).to be_consistent
+      end
+
+      it "should have an externally consistent set of manifests" do
+        dependencies = resolution.dependencies
+        manifests = ManifestSet.new(resolution.manifests)
+
+        expect(manifests).to be_in_compliance_with dependencies
+      end
+    end
+
+  end
+end

data/spec/unit/lockfile_spec.rb

@@ -0,0 +1,65 @@
+require 'librarian'
+require 'librarian/mock'
+
+module Librarian
+  describe Lockfile do
+
+    let(:env) { Mock::Environment.new }
+
+    before do
+      env.registry :clear => true do
+        source 'source-1' do
+          spec 'alpha', '1.1'
+        end
+      end
+    end
+
+    let(:spec) do
+      env.dsl do
+        src 'source-1'
+        dep 'alpha', '1.1'
+      end
+    end
+
+    let(:resolver) { env.resolver }
+    let(:resolution) { resolver.resolve(spec) }
+
+    context "sanity" do
+      context "the resolution" do
+        subject { resolution }
+
+        it { should be_correct }
+        it { should have(1).manifests }
+      end
+    end
+
+    describe "#save" do
+      let(:lockfile) { env.ephemeral_lockfile }
+      let(:lockfile_text) { lockfile.save(resolution) }
+
+      context "just saving" do
+        it "should return the lockfile text" do
+          expect(lockfile_text).to_not be_nil
+        end
+      end
+
+      context "saving and reloading" do
+        let(:reloaded_resolution) { lockfile.load(lockfile_text) }
+
+        it "should have the expected manifests" do
+          expect(reloaded_resolution.manifests.count).to eq resolution.manifests.count
+        end
+      end
+
+      context "bouncing" do
+        let(:bounced_resolution) { lockfile.load(lockfile_text) }
+        let(:bounced_lockfile_text) { lockfile.save(bounced_resolution) }
+
+        it "should return the same lockfile text after bouncing as before bouncing" do
+          expect(bounced_lockfile_text).to eq lockfile_text
+        end
+      end
+    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