social_snippet 0.0.9 → 0.0.10

data/spec/lib/command_line/sspm_install_spec.rb

@@ -1,224 +1,213 @@
 require "spec_helper"
 
-module SocialSnippet::CommandLine
+describe ::SocialSnippet::CommandLine::SSpm::SubCommands::InstallCommand do
 
-  describe SSpm::SubCommands::InstallCommand do
+  before do
+    allow_any_instance_of(
+      ::SocialSnippet::Registry::RegistryResources::Base
+    ).to receive(:rest_client) do
+      ::RestClient::Resource.new "http://api.server/api/dummy"
+    end
+  end
+
+  describe "$ sspm install" do
 
     before do
-      allow_any_instance_of(
-        ::SocialSnippet::Registry::RegistryResources::Base
-      ).to receive(:rest_client) do
-        ::RestClient::Resource.new "http://api.server/api/dummy"
+      allow(fake_core.api).to receive(:resolve_name_by_registry).with("foo") do
+        "url-foo"
       end
-    end
+      allow(fake_core.api).to receive(:resolve_name_by_registry).with("bar") do
+        "url-bar"
+      end
+    end # prepare fake_core.api
 
-    let(:my_repo_info) do
-      {
-        "name" => "my-repo",
-        "desc" => "This is new repository.",
-        "url" => "git://github.com/user/my-repo",
-        "dependencies" => {
-        },
-      }
-    end # result
+    context "create snippet.json" do
 
-    before do
-      WebMock
-        .stub_request(
-          :get,
-          "http://api.server/api/dummy/repositories/my-repo",
-        )
-        .to_return(
-          :status => 200,
-          :body => my_repo_info.to_json,
-          :headers => {
-            "Content-Type" => "application/json",
+      before do
+        ::FileUtils.touch "snippet.json"
+        ::File.write "snippet.json", {
+          :dependencies => {
+            "foo" => "1.2.3",
+            "bar" => "0.0.1"
           },
-        )
-    end # GET /repositories/my-repo/dependencies
-
-    let(:new_repo_info) do
-      {
-        "name" => "new-repo",
-        "desc" => "This is new repository.",
-        "url" => "git://github.com/user/new-repo",
-        "dependencies" => {
-          "my-repo" => "1.0.0",
-        },
-      }
-    end # result
+        }.to_json
+      end
 
-    before do
-      WebMock
-        .stub_request(
-          :get,
-          "http://api.server/api/dummy/repositories/new-repo",
-        )
-        .to_return(
-          :status => 200,
-          :body => new_repo_info.to_json,
-          :headers => {
-            "Content-Type" => "application/json",
-          },
-        )
-    end # GET /repositories/new-repo/dependencies
+      context "prepare command" do
 
-    before do
-      allow(::SocialSnippet::Repository::RepositoryFactory).to receive(:clone).with(/my-repo/) do |url|
-        class FakeRepo
-          attr_reader :path
-        end
+        let(:install_command) { ::SocialSnippet::CommandLine::SSpm::SubCommands::InstallCommand.new [] }
 
-        repo = FakeRepo.new
-        allow(repo).to receive(:path).and_return "/path/to/my-repo"
-        allow(repo).to receive(:name).and_return "my-repo"
-        allow(repo).to receive(:create_cache).and_return ""
-        allow(repo).to receive(:has_versions?).and_return true
-        allow(repo).to receive(:latest_version).and_return "1.2.3"
-        allow(repo).to receive(:dependencies).and_return({})
-        repo
-      end
-    end # prepare my-repo
+        context "run command" do
 
-    before do
-      allow(::SocialSnippet::Repository::RepositoryFactory).to receive(:clone).with(/new-repo/) do |url|
-        class FakeRepo
-          attr_reader :path
-        end
+          before do
+            allow(fake_core.api).to receive(:install_repository)
+          end
 
-        repo = FakeRepo.new
-        allow(repo).to receive(:path).and_return "/path/to/new-repo"
-        allow(repo).to receive(:name).and_return "new-repo"
-        allow(repo).to receive(:create_cache).and_return ""
-        allow(repo).to receive(:has_versions?).and_return true
-        allow(repo).to receive(:latest_version).and_return "1.2.4"
-        allow(repo).to receive(:dependencies).and_return new_repo_info["dependencies"]
-        repo
-      end
-    end # prepare new-repo
+          before do
+            install_command.init
+            install_command.run
+          end
 
-    before do
-      allow(::FileUtils).to receive(:cp_r) do
-        # do nothing
-      end
-    end
+          it { expect(fake_core.api).to have_received(:install_repository).with("url-foo", "1.2.3", kind_of(::Hash)).once }
+          it { expect(fake_core.api).to have_received(:install_repository).with("url-bar", "0.0.1", kind_of(::Hash)).once }
 
-    #
-    # main
-    #
-    let(:install_command_output) { ::StringIO.new }
-    let(:install_command_logger) { ::SocialSnippet::Logger.new install_command_output }
-    before { allow(fake_core).to receive(:logger).and_return install_command_logger }
+          context "re-install" do
 
-    describe "$ sspm install" do
+            let(:re_install_command) { ::SocialSnippet::CommandLine::SSpm::SubCommands::InstallCommand.new [] }
 
-      context "create snippet.json" do
+            before do
+              re_install_command.init
+              re_install_command.run
+            end
 
-        before do
-          FileUtils.touch "snippet.json"
-          File.write "snippet.json", {
-            :dependencies => {
-              "foo" => "1.2.3",
-              "bar" => "0.0.1"
-            },
-          }.to_json
-        end
+            it { expect(fake_core.api).to have_received(:install_repository).with("url-foo", "1.2.3", kind_of(::Hash)).twice }
+            it { expect(fake_core.api).to have_received(:install_repository).with("url-bar", "0.0.1", kind_of(::Hash)).twice }
 
-        example do
-          install_command = SSpm::SubCommands::InstallCommand.new([])
-          expect(fake_core.api).to receive(:install_repository_by_name).with("foo", "1.2.3", kind_of(Hash)).once
-          expect(fake_core.api).to receive(:install_repository_by_name).with("bar", "0.0.1", kind_of(Hash)).once
-          install_command.run
-        end
+          end # re-install
+
+        end # run command
+
+      end # prepare command
 
-      end # create snippet.json
+    end # create snippet.json
 
-    end # $ sspm install
+  end # $ sspm install
 
-    describe "$ sspm install my-repo" do
+  describe "$ sspm install my-repo" do
 
-      let(:install_command_output) { ::StringIO.new }
-      let(:install_command_logger) { ::SocialSnippet::Logger.new install_command_output }
+    context "prepare registry info" do
 
       before do
-        install_command_logger.level = ::SocialSnippet::Logger::Severity::INFO
-        allow(fake_core).to receive(:logger).and_return install_command_logger
-        install_command = SSpm::SubCommands::InstallCommand.new ["my-repo"]
-        install_command.init
-        install_command.run
+        allow(fake_core.api).to receive(:resolve_name_by_registry).with("my-repo") do
+          "git://driver.test/user/my-repo"
+        end
       end
 
-      subject { install_command_output.string }
-      it { should match(/my-repo/) }
-      it { should match(/Installing/) }
-      it { should match(/Cloning/) }
-      it { should match(/Success/) }
-      it { should_not match(/dependencies/) }
-
-      context "$ sspm install my-repo (second)" do
-
-        let(:second_install_command_output) { ::StringIO.new }
-        let(:second_install_command_logger) { ::SocialSnippet::Logger.new second_install_command_output }
-
-        subject do
-          install_command_logger.level = ::SocialSnippet::Logger::Severity::INFO
-          allow(fake_core).to receive(:logger).and_return second_install_command_logger
-          install_command = SSpm::SubCommands::InstallCommand.new ["my-repo"]
-          install_command.init
-          install_command.run
-          second_install_command_output.string
+      before do
+        allow(fake_core.api).to receive(:install_repository)
+      end
+
+      context "prepare command" do
+        let(:install_command) { ::SocialSnippet::CommandLine::SSpm::SubCommands::InstallCommand.new ["my-repo"] }
+        before { install_command.init }
+        context "run command" do
+          before { install_command.run }
+          it { expect(fake_core.api).to have_received(:install_repository).with("git://driver.test/user/my-repo", nil, kind_of(::Hash)).once }
         end
+      end # prepare command
 
-        it { should match(/my-repo/) }
-        it { should_not match(/Installing/) }
-        it { should_not match(/Cloning/) }
-        it { should_not match(/Success/) }
-        it { should_not match(/dependencies/) }
+    end # prepare registry info
 
-      end # (reinstall) $ sspm install my-repo
+  end # $ sspm install my-repo
 
-    end # $ sspm install my-repo
+  describe "package dependencies" do
 
-    describe "$ sspm install new-repo" do
+    context "prepare registry info" do
 
       before do
-        install_command = SSpm::SubCommands::InstallCommand.new ["new-repo"]
-        install_command.init
-        install_command.run
+        allow(fake_core.api).to receive(:resolve_name_by_registry).with("my-repo") do
+          "git://driver.test/user/my-repo"
+        end
+        allow(fake_core.api).to receive(:resolve_name_by_registry).with("new-repo") do
+          "git://driver.test/user/new-repo"
+        end
       end
 
-      subject { install_command_output.string }
-      it { should match(/my-repo/) }
-      it { should match(/new-repo/) }
-      it { should match(/my-repo.*new-repo/m) }
-      it { should match(/Installing: new-repo#1.2.4/) }
-      it { should match(/Installing: my-repo#1.0.0/) }
-      it { should match(/Cloning/) }
-      it { should match(/Success/) }
-      it { should match(/Finding new-repo#1.2.4's/) }
+      context "already installed my-repo" do
 
-    end # $ sspm install new-repo
+        before do
+          repo = ::SocialSnippet::Repository::Models::Repository.find_or_create_by(:name => "my-repo")
+          repo.add_ref "1.2.3", "rev-1.2.3"
+          repo.add_package "1.2.3"
+          ::SocialSnippet::Repository::Models::Package.create(
+            :repo_name => "my-repo",
+            :rev_hash => "rev-1.2.3",
+          )
+        end
 
-    describe "$ sspm install --dry-run new-repo" do
+        context "install new-repo" do
 
-      before do
-        install_command = SSpm::SubCommands::InstallCommand.new ["--dry-run", "new-repo"]
-        install_command.init
-        install_command.run
-      end
+          let(:install_command) { ::SocialSnippet::CommandLine::SSpm::SubCommands::InstallCommand.new ["new-repo"] }
+          before { install_command.init }
+
+          context "prepare stubs" do
+
+            before do
+              allow(fake_core.repo_manager).to receive(:install).with("git://driver.test/user/new-repo", nil, kind_of(::Hash)).once do
+                pkg = ::SocialSnippet::Repository::Models::Package.new
+                pkg.add_dependency "my-repo", "1.2.3"
+                pkg
+              end
+            end
+
+            before do
+              allow(fake_core.api).to receive(:install_repository).and_call_original
+            end
+
+            context "run-command" do
+              before { install_command.run }
+              it { expect(fake_core.api).to_not have_received(:install_repository).with("git://driver.test/user/my-repo", "1.2.3", kind_of(::Hash)) }
+              it { expect(fake_core.api).to have_received(:install_repository).with("git://driver.test/user/new-repo", nil, kind_of(::Hash)).once }
+            end
+
+          end # prepare stubs
+
+        end # prepare args
+
+      end # already installed my-repo
+
+      context "install new-repo" do
+
+        let(:install_command) { ::SocialSnippet::CommandLine::SSpm::SubCommands::InstallCommand.new ["new-repo"] }
+        before { install_command.init }
+
+        context "prepare stubs" do
+
+          before do
+            allow(fake_core.repo_manager).to receive(:install).with("git://driver.test/user/my-repo", "1.2.3", kind_of(::Hash)) do
+              repo = ::SocialSnippet::Repository::Models::Repository.find_or_create_by(:name => "my-repo")
+              repo.add_ref "1.2.3", "rev-1.2.3"
+              repo.add_package "1.2.3"
+              ::SocialSnippet::Repository::Models::Package.create(
+                :repo_name => "my-repo",
+                :rev_hash => "rev-1.2.3",
+              )
+            end
+            allow(fake_core.repo_manager).to receive(:install).with("git://driver.test/user/new-repo", nil, kind_of(::Hash)) do
+              repo = ::SocialSnippet::Repository::Models::Repository.find_or_create_by(:name => "new-repo")
+              pkg = ::SocialSnippet::Repository::Models::Package.new
+              pkg.add_dependency "my-repo", "1.2.3"
+              pkg
+            end
+          end
+
+          before { allow(fake_core.api).to receive(:install_repository).and_call_original }
+
+          context "run-command" do
+
+            before { install_command.run }
+            it { expect(fake_core.api).to have_received(:install_repository).with("git://driver.test/user/my-repo", "1.2.3", kind_of(::Hash)).once }
+            it { expect(fake_core.api).to have_received(:install_repository).with("git://driver.test/user/new-repo", nil, kind_of(::Hash)).once }
+
+            context "re-install new-repo" do
+              let(:re_install_command) { ::SocialSnippet::CommandLine::SSpm::SubCommands::InstallCommand.new ["new-repo"] }
+              before { re_install_command.init }
+              context "run-command" do
+                before { re_install_command.run }
+                it { expect(fake_core.api).to have_received(:install_repository).with("git://driver.test/user/my-repo", "1.2.3", kind_of(::Hash)).once }
+                it { expect(fake_core.api).to have_received(:install_repository).with("git://driver.test/user/new-repo", nil, kind_of(::Hash)).twice }
+              end
+            end
+
+          end
+
+        end # prepare stubs
+
+      end # prepare args
 
-      subject { install_command_output.string }
-      it { should match(/my-repo/) }
-      it { should match(/new-repo/) }
-      it { should match(/new-repo.*my-repo/m) }
-      it { should match(/Installing: new-repo#1.2.4/) }
-      it { should match(/Installing: my-repo#1.0.0/) }
-      it { should match(/Cloning/) }
-      it { should match(/Finding new-repo#1.2.4's/) }
-      it { should match(/Success/) }
+    end # prepare registry info
 
-    end # $ sspm install new-repo
+  end
 
-  end # SSpm::SubCommands::InstallCommand
+end # ::SocialSnippet::CommandLine::SSpm::SubCommands::InstallCommand
 
-end # SocialSnippet::CommandLine

data/spec/lib/command_line/sspm_update_spec.rb

@@ -0,0 +1,56 @@
+require "spec_helper"
+
+describe ::SocialSnippet::CommandLine::SSpm::SubCommands::UpdateCommand do
+
+  describe "$ sspm update" do
+
+    before { allow(fake_core.api).to receive(:update_repository) }
+
+    context "prepare repositories" do
+
+      before do
+        ::SocialSnippet::Repository::Models::Repository.create(
+          :name => "repo-1",
+          :url => "url-repo-1",
+        )
+      end
+
+      before do
+        ::SocialSnippet::Repository::Models::Repository.create(
+          :name => "repo-2",
+          :url => "url-repo-2",
+        )
+      end
+
+      context "update all" do
+
+        let(:update_command) { ::SocialSnippet::CommandLine::SSpm::SubCommands::UpdateCommand.new [] }
+        before { update_command.init }
+
+        context "run command" do
+          before { update_command.run }
+          it { expect(fake_core.api).to have_received(:update_repository).with("repo-1", kind_of(::Hash)).once }
+          it { expect(fake_core.api).to have_received(:update_repository).with("repo-2", kind_of(::Hash)).once }
+        end
+
+      end # update all
+
+      context "update repo-1" do
+
+        let(:update_command) { ::SocialSnippet::CommandLine::SSpm::SubCommands::UpdateCommand.new ["repo-1"] }
+        before { update_command.init }
+
+        context "run command" do
+          before { update_command.run }
+          it { expect(fake_core.api).to have_received(:update_repository).with("repo-1", kind_of(::Hash)).once }
+          it { expect(fake_core.api).to_not have_received(:update_repository).with("repo-2", kind_of(::Hash)) }
+        end
+
+      end # update repo-1
+
+    end # prepare repositories
+
+  end # $ sspm update
+
+end # ::SocialSnippet::CommandLine::SSpm::SubCommands::UpdateCommand
+

data/spec/lib/config_spec.rb

@@ -2,12 +2,6 @@ require "spec_helper"
 
 describe SocialSnippet::Config, :without_fakefs => $WITHOUT_FAKEFS do
 
-  let(:logger) do
-    logger = ::SocialSnippet::Logger.new(STDOUT)
-    logger.level = ::SocialSnippet::Logger::Severity::UNKNOWN
-    logger
-  end
-
   let(:social_snippet) do
     class Fake; end
     Fake.new
@@ -17,7 +11,11 @@ describe SocialSnippet::Config, :without_fakefs => $WITHOUT_FAKEFS do
     ::SocialSnippet::Config.new(social_snippet)
   end
 
-  before { stub_const "ENV", "HOME" => Dir.mktmpdir }
+  before do
+    allow(social_snippet).to receive(:storage).and_return fake_storage
+  end
+
+  before { stub_const "ENV", "HOME" => ::Dir.mktmpdir }
 
   describe "sspm_url" do
 
@@ -106,7 +104,7 @@ describe SocialSnippet::Config, :without_fakefs => $WITHOUT_FAKEFS do
 
   context "set ENV[SOCIAL_SNIPPET_HOME]" do
 
-    before { stub_const "ENV", "HOME" => Dir.mktmpdir, "SOCIAL_SNIPPET_HOME" => Dir.mktmpdir }
+    before { stub_const "ENV", "HOME" => ::Dir.mktmpdir, "SOCIAL_SNIPPET_HOME" => Dir.mktmpdir }
     it { expect(config.home).to_not eq ::File.join(ENV["HOME"], ".social-snippet") }
     it { expect(config.home).to eq ENV["SOCIAL_SNIPPET_HOME"] }
     it { expect(config.file_path).to eq ::File.join(ENV["SOCIAL_SNIPPET_HOME"], "config.json") }