me 0.0.1 → 1.0.0

data/spec/me/cli/git_config_command_spec.rb

@@ -0,0 +1,53 @@
+require "me/cli/git_config_command"
+require "me/registry"
+
+module Me
+  module Cli
+    RSpec.describe GitConfigCommand do
+      subject(:command) { described_class.new(identity_name, name, email) }
+
+      let(:identity_name) { double("Identity Name") }
+
+      let(:git_config) { instance_double(GitConfig, configure: nil) }
+      let(:actual_git_config) { instance_double(GitConfig) }
+
+      let(:mapper_factory) { class_double(GitConfig::Mapper) }
+      let(:mapper) { instance_double(GitConfig::Mapper, find: git_config) }
+
+      before do
+        Registry.register_git_config_mapper_factory(mapper_factory)
+
+        allow(mapper_factory)
+          .to receive(:new)
+          .with(name, email, identity_name)
+          .and_return(mapper)
+
+        allow(mapper_factory)
+          .to receive(:find_by_identity)
+          .with(identity_name)
+          .and_return(actual_git_config)
+
+        allow(actual_git_config)
+          .to receive(:build_view)
+          .with(GitConfigView)
+          .and_return(GitConfigView.new(name: name, email: email))
+      end
+
+      describe "#call" do
+        context "when name and email specified" do
+          let(:name) { "john" }
+          let(:email) { "john@example.org" }
+
+          it "configures git" do
+            expect(git_config).to receive(:configure).once
+            command.call
+          end
+
+          it "renders new configuration" do
+            expect(command.call.to_s).to eq("name:  john\nemail: john@example.org")
+          end
+        end
+      end
+    end
+  end
+end

data/spec/me/cli/ssh_config_command_spec.rb

@@ -0,0 +1,54 @@
+require "me/cli/ssh_config_command"
+require "me/registry"
+
+module Me
+  module Cli
+    RSpec.describe SshConfigCommand do
+      subject(:command) { described_class.new(identity_name, keys) }
+
+      let(:identity_name) { double("Identity Name") }
+
+      let(:ssh_config) { instance_double(SshConfig, configure: nil) }
+      let(:actual_ssh_config) { instance_double(SshConfig) }
+
+      let(:expected_keys) { ["id_rsa", "id_dsa", "github.rsa"] }
+
+      let(:mapper_factory) { class_double(SshConfig::Mapper) }
+      let(:mapper) { instance_double(SshConfig::Mapper, find: ssh_config) }
+
+      before do
+        Registry.register_ssh_config_mapper_factory(mapper_factory)
+
+        allow(mapper_factory)
+          .to receive(:new)
+          .with(keys, identity_name)
+          .and_return(mapper)
+
+        allow(mapper_factory)
+          .to receive(:find_by_identity)
+          .with(identity_name)
+          .and_return(actual_ssh_config)
+
+        allow(actual_ssh_config)
+          .to receive(:build_view)
+          .with(SshConfigView)
+          .and_return(SshConfigView.new(keys: expected_keys))
+      end
+
+      describe "#call" do
+        context "when there are some keys" do
+          let(:keys) { instance_double(Array, empty?: false) }
+
+          it "configures ssh with this keys" do
+            expect(ssh_config).to receive(:configure).once
+            command.call
+          end
+
+          it "responds with new key list" do
+            expect(command.call.to_s).to eq("keys:\n- id_rsa\n- id_dsa\n- github.rsa")
+          end
+        end
+      end
+    end
+  end
+end

data/spec/me/cli/switch_command_spec.rb

@@ -0,0 +1,64 @@
+require "me/cli/switch_command"
+require "me/registry"
+
+module Me
+  module Cli
+    RSpec.describe SwitchCommand do
+      subject(:command) { described_class.new(name) }
+
+      let(:name) { double("Name") }
+
+      let(:identity) { double("Identity") }
+      let(:mapper_factory) { class_double(Identity::Mapper) }
+      let(:mapper) { instance_double(Identity::Mapper, find: identity) }
+
+      let(:active_identity) { double("Active Identity") }
+
+      let(:activate_command) { instance_double(ActivateCommand, call: activation_views) }
+      let(:activation_views) { [activation_view_a, activation_view_b] }
+
+      let(:activation_view_a) { double("View") }
+      let(:activation_view_b) { double("View") }
+
+      before do
+        Registry.register_identity_mapper_factory(mapper_factory)
+
+        allow(Identity).to receive(:active).and_return(active_identity)
+        allow(identity).to receive(:activate)
+        allow(active_identity)
+          .to receive(:build_view)
+          .with(NewActiveIdentityView)
+          .and_return(NewActiveIdentityView.new(name: "new_identity"))
+
+        allow(mapper_factory)
+          .to receive(:new)
+          .with(name)
+          .and_return(mapper)
+
+        allow(ActivateCommand)
+          .to receive(:new)
+          .and_return(activate_command)
+      end
+
+      describe "#call" do
+        it "activates new identity" do
+          expect(identity).to receive(:activate).once
+          command.call
+        end
+
+        it "activates configuration" do
+          expect(activate_command).to receive(:call).and_return(activation_views)
+          command.call
+        end
+
+        it "responds with new active identity" do
+          expect(command.call[0].to_s).to eq("New active identity: new_identity")
+        end
+
+        it "responds with activation views too" do
+          expect(command.call[1..-1]).to eq(activation_views)
+        end
+      end
+    end
+  end
+end

data/spec/me/cli/whoami_command_spec.rb

@@ -0,0 +1,26 @@
+require "me/cli/whoami_command"
+require "me/registry"
+
+module Me
+  module Cli
+    RSpec.describe WhoamiCommand do
+      subject(:command) { described_class.new }
+
+      let(:identity) { instance_double(Identity) }
+
+      before do
+        allow(Identity).to receive(:active).and_return(identity)
+        allow(identity)
+          .to receive(:build_view)
+          .with(ActiveIdentityView)
+          .and_return(ActiveIdentityView.new(name: "personal"))
+      end
+
+      describe "#call" do
+        it "has expected response" do
+          expect(command.call.to_s).to eq("Active identity: personal")
+        end
+      end
+    end
+  end
+end

data/spec/me/executor_spec.rb

@@ -0,0 +1,23 @@
+require "me/executor"
+
+module Me
+  RSpec.describe Executor do
+    subject(:executor) { described_class.new }
+
+    let(:args) { [double("arg"), double("arg"), double("arg")] }
+    let(:kernel) { double("Kernel") }
+
+    before do
+      Registry.register_kernel(kernel)
+    end
+
+    describe "#call" do
+      it "delegates to kernel" do
+        expect(kernel)
+          .to receive(:system)
+          .with(*args)
+        executor.call(args)
+      end
+    end
+  end
+end

data/spec/me/git_config_spec.rb

@@ -0,0 +1,150 @@
+require "me/git_config"
+require "me/activation"
+require "me/executor"
+require "me/registry"
+
+module Me
+  RSpec.describe GitConfig do
+    subject(:git_config) { GitConfig.new(name, email, identity_name).with_mapper(mapper) }
+
+    let(:name) { "sarah" }
+    let(:email) { "sarah.o@example.org" }
+
+    let(:identity_name) { "sarah_personal" }
+
+    let(:mapper_factory) { class_double(GitConfig::Mapper) }
+    let(:mapper) { instance_double(GitConfig::Mapper) }
+
+    let(:git_config_hash) { { "name" => name, "email" => email } }
+
+    let(:executor_factory) { class_double(Executor, new: executor) }
+    let(:executor) { instance_double(Executor, call: nil) }
+
+    before do
+      Registry.register_git_config_mapper_factory(mapper_factory)
+      allow(mapper_factory)
+        .to receive(:find_by_identity)
+        .with(identity_name)
+        .and_return(git_config)
+
+      Registry.register_executor_factory(executor_factory)
+    end
+
+    describe "#initialize" do
+      it "creates and object out of name and email" do
+        expect(GitConfig.new("john", "john@example.org", identity_name))
+          .to eq(GitConfig.new("john", "john@example.org", identity_name))
+      end
+
+      it "can be created with identity" do
+        expect(GitConfig.new("john", "john@example.org", identity_name))
+          .to eq(GitConfig.new("john", "john@example.org", identity_name))
+      end
+    end
+
+    describe "#==" do
+      it "is equal to git config with the same name and email" do
+        expect(GitConfig.new("james", "james.black@example.org", identity_name))
+          .to eq(GitConfig.new("james", "james.black@example.org", identity_name))
+      end
+
+      it "is not equal to git config with different name or email" do
+        expect(GitConfig.new("james", "james.black@example.org", identity_name))
+          .not_to eq(GitConfig.new("john", "james.black@example.org", identity_name))
+
+        expect(GitConfig.new("james", "james.black@example.org", identity_name))
+          .not_to eq(GitConfig.new("james", "john.smith@example.org", identity_name))
+
+        expect(GitConfig.new("james", "james.black@example.org", identity_name))
+          .not_to eq(GitConfig.new("john", "john.smith@example.org", identity_name))
+      end
+
+      it "handles edge cases properly" do
+        expect(GitConfig.new("james", "james.black@example.org", identity_name)).not_to eq(nil)
+        expect(GitConfig.new("james", "james.black@example.org", identity_name)).not_to eq(Object.new)
+      end
+
+      it "doesn't care about identity" do
+        expect(GitConfig.new("james", "james.black@example.org", identity_name))
+          .to eq(GitConfig.new("james", "james.black@example.org", "different name"))
+      end
+    end
+
+    describe ".for_identity" do
+      subject(:git_config_from_identity) { GitConfig.for_identity(identity_name) }
+      let(:a_git_config) { instance_double(GitConfig) }
+
+      before do
+        allow(mapper_factory)
+          .to receive(:find_by_identity)
+          .with(identity_name)
+          .and_return(a_git_config)
+      end
+
+      it "finds git config for specified identity" do
+        expect(git_config_from_identity).to eq(a_git_config)
+      end
+    end
+
+    describe "#configure" do
+      context "when name and email are present" do
+        it "delegates to store to configure git" do
+          expect(mapper)
+            .to receive(:update)
+            .with(name: name, email: email)
+            .once
+
+          git_config.configure
+        end
+      end
+
+      context "when name or email is not present" do
+        let(:name) { nil }
+        let(:email) { nil }
+
+        it "does nothing" do
+          expect(mapper).not_to receive(:update)
+          git_config.configure
+        end
+      end
+    end
+
+    describe "#build_view" do
+      let(:view_factory) { double("ViewFactory") }
+      let(:view) { double("View") }
+
+      it "gives name and email to view factory" do
+        allow(view_factory)
+          .to receive(:new)
+          .with(name: name, email: email)
+          .and_return(view)
+        expect(git_config.build_view(view_factory)).to eq(view)
+      end
+    end
+
+    describe "#activate" do
+      it "sets up global git user.email config" do
+        expect(executor)
+          .to receive(:call)
+          .with(["git", "config", "--global", "user.email", email])
+        git_config.activate
+      end
+
+      it "sets up global git user.name config" do
+        expect(executor)
+          .to receive(:call)
+          .with(["git", "config", "--global", "user.name", name])
+        git_config.activate
+      end
+
+      it "returns an activation" do
+        expect(git_config.activate).to eq(
+          Activation.new._with_commands([
+            ["git", "config", "--global", "user.name", name],
+            ["git", "config", "--global", "user.email", email],
+          ])
+        )
+      end
+    end
+  end
+end

data/spec/me/identity_spec.rb

@@ -0,0 +1,101 @@
+require "me/identity"
+require "me/git_config"
+require "me/ssh_config"
+require "me/registry"
+
+module Me
+  RSpec.describe Identity do
+    subject(:identity) { Identity.new(name).with_mapper(mapper) }
+
+    let(:name) { "john" }
+
+    let(:mapper_factory) { class_double(Identity::Mapper, new: active_mapper) }
+    let(:active_mapper) { instance_double(Identity::Mapper) }
+    let(:mapper) { instance_double(Identity::Mapper) }
+
+    let(:git_config) { instance_double(GitConfig) }
+    let(:ssh_config) { instance_double(SshConfig) }
+
+    before do
+      Registry.register_identity_mapper_factory(mapper_factory)
+      allow(mapper_factory)
+        .to receive(:new)
+        .with(name)
+        .and_return(mapper)
+
+      allow(GitConfig)
+        .to receive(:for_identity)
+        .with(name)
+        .and_return(git_config)
+
+      allow(SshConfig)
+        .to receive(:for_identity)
+        .with(name)
+        .and_return(ssh_config)
+    end
+
+    describe "#initialize" do
+      it "can be created with name" do
+        expect(Identity.new("john")).to eq(Identity.new("john"))
+      end
+    end
+
+    describe "#==" do
+      it "is equal to the identity with the same name" do
+        expect(Identity.new("james")).to eq(Identity.new("james"))
+      end
+
+      it "is not equal to the identity with different name" do
+        expect(Identity.new("james")).not_to eq(Identity.new("john"))
+      end
+
+      it "handles edge cases properly" do
+        expect(Identity.new("james")).not_to eq(nil)
+        expect(Identity.new("sarah")).not_to eq(Object.new)
+      end
+    end
+
+    describe ".active" do
+      it "returns active identity" do
+        expected = instance_double(Identity)
+        allow(active_mapper).to receive(:find).and_return(expected)
+        expect(Identity.active).to eq(expected)
+      end
+    end
+
+    describe "#build_view" do
+      let(:view_factory) { double("ViewFactory") }
+      let(:view) { double("View") }
+
+      before do
+        allow(view_factory)
+          .to receive(:new)
+          .with(name: name)
+          .and_return(view)
+      end
+
+      it "gives the view its name" do
+        expect(identity.build_view(view_factory)).to eq(view)
+      end
+    end
+
+    describe "#activate" do
+      it "calls update on mapper with active_identity = name" do
+        expect(mapper).to receive(:update).with(active_identity: name).once
+        identity.activate
+      end
+    end
+
+    describe "#git_config" do
+      it "returns git config for this identity" do
+        expect(identity.git_config).to eq(git_config)
+      end
+    end
+
+    describe "#ssh_config" do
+      it "returns ssh config for this identity" do
+        expect(identity.ssh_config).to eq(ssh_config)
+      end
+    end
+  end
+end

data/spec/me/mappers/git_config_store2_spec.rb

@@ -0,0 +1,71 @@
+require "me/mappers/git_config_store2"
+
+module Me
+  module Mappers
+    RSpec.describe GitConfigStore2 do
+      let(:email) { "john@example.org" }
+      let(:name) { "John Smith" }
+      let(:identity) { "john_personal" }
+
+      before do
+        described_class.new(name, email, identity).update(name: name, email: email)
+      end
+
+      describe ".find_by_identity" do
+        it "finds an identity if it is present" do
+          expect(described_class.find_by_identity(identity))
+            .to eq(GitConfig.new(name, email, identity))
+        end
+
+        it "fails with GitNotConfigured error if git configuration is not present" do
+          expect {
+            described_class.find_by_identity("other")
+          }.to raise_error(Errors::GitNotConfigured)
+        end
+      end
+
+      describe "#find" do
+        it "returns GitConfig with same attributes" do
+          expect(described_class.new("a name", "a email", "a identity").find)
+            .to eq(GitConfig.new("a name", "a email", "a identity"))
+        end
+
+        it "fails with GitNotConfigured when name or email is not provided" do
+          expect {
+            described_class.new(nil, "a email", "a identity").find
+          }.to raise_error(Errors::GitNotConfigured)
+
+          expect {
+            described_class.new("a name", nil, "a identity").find
+          }.to raise_error(Errors::GitNotConfigured)
+        end
+
+        it "populates GitConfig with missing attributes if it is able to find it" do
+          expect(described_class.new(nil, "a email", identity).find)
+            .to eq(GitConfig.new(name, "a email", identity))
+        end
+      end
+
+      describe "#update" do
+        it "allows to update name" do
+          described_class.new("a name", "a email", identity).update(name: "John")
+          expect(described_class.find_by_identity(identity))
+            .to eq(GitConfig.new("John", email, identity))
+        end
+
+        it "allows to update email" do
+          described_class.new("a name", "a email", identity).update(email: "john@corporation.com")
+          expect(described_class.find_by_identity(identity))
+            .to eq(GitConfig.new(name, "john@corporation.com", identity))
+        end
+
+        it "allows to create new configuration" do
+          described_class.new("a name", "a email", "an identity")
+            .update(name: "James", email: "james@corporation.com")
+          expect(described_class.find_by_identity("an identity"))
+            .to eq(GitConfig.new("James", "james@corporation.com", "an identity"))
+        end
+      end
+    end
+  end
+end

data/spec/me/mappers/identity_store2_spec.rb

@@ -0,0 +1,37 @@
+require "me/mappers/identity_store2"
+
+module Me
+  module Mappers
+    RSpec.describe IdentityStore2 do
+      subject(:mapper) { described_class.new(name) }
+      subject(:active_mapper) { described_class.new }
+
+      let(:name) { "sarah" }
+      let(:active_identity) { "james" }
+
+      before do
+        store = Store2.build
+        store.set("active_identity", active_identity)
+        store.save
+      end
+
+      describe "#find" do
+        it "returns identity with specified name" do
+          expect(mapper.find)
+            .to eq(Identity.new(name))
+
+          expect(active_mapper.find)
+            .to eq(Identity.new(active_identity))
+        end
+      end
+
+      describe "#update" do
+        it "allows to change active identity" do
+          mapper.update(active_identity: "john")
+          expect(active_mapper.find)
+            .to eq(Identity.new("john"))
+        end
+      end
+    end
+  end
+end

data/spec/me/mappers/ssh_config_store2_spec.rb

@@ -0,0 +1,65 @@
+require "me/mappers/ssh_config_store2"
+
+module Me
+  module Mappers
+    RSpec.describe SshConfigStore2 do
+      let(:keys) { ["id_rsa", "id_dsa", "github.rsa"] }
+      let(:identity) { "work" }
+
+      before do
+        described_class.new(keys, identity).update(keys: keys)
+      end
+
+      describe ".find_by_identity" do
+        it "returns SshConfig instance with provided identity given it is present" do
+          expect(described_class.find_by_identity(identity))
+            .to eq(SshConfig.new(keys, identity))
+        end
+
+        it "fails with SshNotConfigured error if provided identity is not present" do
+          expect {
+            described_class.find_by_identity("another identity")
+          }.to raise_error(Errors::SshNotConfigured)
+        end
+      end
+
+      describe "#find" do
+        it "returns SshConfig with same attributes" do
+          expect(described_class.new(["a key", "another key"], "an identity").find)
+            .to eq(SshConfig.new(["a key", "another key"], "an identity"))
+        end
+
+        it "fails with SshNotConfigured error if keys are not present" do
+          expect {
+            described_class.new(nil, "an identity").find
+          }.to raise_error(Errors::SshNotConfigured)
+
+          expect {
+            described_class.new([], "an identity").find
+          }.to raise_error(Errors::SshNotConfigured)
+        end
+
+        it "populates SshConfig if it is able to find it" do
+          expect(described_class.new(nil, identity).find)
+            .to eq(SshConfig.new(keys, identity))
+        end
+      end
+
+      describe "#update" do
+        it "allows to update keys" do
+          keys = ["rsa key", "another key", "new key"]
+          described_class.new(["a key", "another key"], identity).update(keys: keys)
+          expect(described_class.find_by_identity(identity))
+            .to eq(SshConfig.new(keys, identity))
+        end
+
+        it "is able to create new configuration" do
+          keys = ["rsa key", "another key", "new key"]
+          described_class.new(keys, "another identity").update(keys: keys)
+          expect(described_class.find_by_identity("another identity"))
+            .to eq(SshConfig.new(keys, "another identity"))
+        end
+      end
+    end
+  end
+end