gitsu 0.0.1

data/spec/gitsu/gitsu_spec.rb

@@ -0,0 +1,177 @@
+require 'spec_helper'
+
+module GitSu
+    describe Gitsu do
+        let(:output) { double('output') }
+        let(:switcher) { double('switcher') }
+        let(:gitsu) { GitSu::Gitsu.new(switcher, output) }
+
+        describe '#go' do
+            context 'when query string provided' do
+                context 'when no scope specified' do
+                    it 'switches to the specified user in the default scope' do
+                        switcher.should_receive(:request).with('Joe Bloggs', :default)
+                        gitsu.go ['Joe', 'Bloggs']
+                    end
+                end
+
+                context 'when local scope specified' do
+                    context 'as short option (-l)' do
+                        it 'switches to the specified user in the default scope' do
+                            switcher.should_receive(:request).with('Joe Bloggs', :local)
+                            gitsu.go ['Joe', 'Bloggs', "-l"]
+                        end
+                    end
+                    context 'as long option (--local)' do
+                        it 'switches to the specified user in the default scope' do
+                            switcher.should_receive(:request).with('Joe Bloggs', :local)
+                            gitsu.go ['Joe', 'Bloggs', "--local"]
+                        end
+                    end
+                end
+
+                context 'when global scope specified' do
+                    context 'as short option (-g)' do
+                        it 'switches to the specified user in the global scope' do
+                            switcher.should_receive(:request).with('Joe Bloggs', :global)
+                            gitsu.go ['Joe', 'Bloggs', "-g"]
+                        end
+                    end
+                    context 'as long option (--global)' do
+                        it 'switches to the specified user in the global scope' do
+                            switcher.should_receive(:request).with('Joe Bloggs', :global)
+                            gitsu.go ['Joe', 'Bloggs', "--global"]
+                        end
+                    end
+                end
+
+                context 'when system scope specified' do
+                    context 'as short option (-s)' do
+                        it 'switches to the specified user in the system scope' do
+                            switcher.should_receive(:request).with('Joe Bloggs', :system)
+                            gitsu.go ['Joe', 'Bloggs', "-s"]
+                        end
+                    end
+                    context 'as long option (--system)' do
+                        it 'switches to the specified user in the system scope' do
+                            switcher.should_receive(:request).with('Joe Bloggs', :system)
+                            gitsu.go ['Joe', 'Bloggs', "--system"]
+                        end
+                    end
+                end
+
+                context 'when multiple scopes specified' do
+                    it 'switches to the specified user in the specified scopes' do
+                        switcher.should_receive(:request).with('Joe Bloggs', :local)
+                        switcher.should_receive(:request).with('Joe Bloggs', :global)
+                        switcher.should_receive(:request).with('Joe Bloggs', :system)
+                        gitsu.go ['Joe', 'Bloggs', "--local", "--global", "--system"]
+                    end
+                end
+            end
+            
+            context 'when no query provided' do
+                context 'when no scope specified' do
+                    it 'prints all users' do
+                        switcher.should_receive(:print_current).with(:all)
+                        gitsu.go []
+                    end
+                end
+
+                context 'when scope specified' do
+                    it 'prints the current user in the specified scope' do
+                        switcher.should_receive(:print_current).with(:system)
+                        gitsu.go ["--system"]
+                    end
+                end
+
+                context 'when multiple scopes specified' do
+                    it 'prints the current user in the specified scopes' do
+                        switcher.should_receive(:print_current).with(:local, :system)
+                        gitsu.go ["--local", "--system"]
+                    end
+                end
+            end
+            
+            context 'when "clear" option passed' do
+                context "no scope is specified" do
+                    context 'short option (-c)' do
+                        it 'clears all Git users' do
+                            switcher.should_receive(:clear).with(:all)
+                            gitsu.go ["-c"]
+                        end
+                    end
+
+                    context 'long option (--clear)' do
+                        it 'clears all Git users' do
+                            switcher.should_receive(:clear).with(:all)
+                            gitsu.go ["--clear"]
+                        end
+                    end
+                end
+
+                context 'scope is specified' do
+                    it 'clears the user in that scope' do
+                        switcher.should_receive(:clear).with(:local)
+                        gitsu.go ["--clear", "--local"]
+                    end
+                end
+
+                context 'mulitple scopes are specified' do
+                    it 'clears the user in those scopes' do
+                        switcher.should_receive(:clear).with(:local, :system)
+                        gitsu.go ["--clear", "--local", "--system"]
+                    end
+                end
+            end
+            
+            context 'when "add" option passed' do
+                context 'short option (-a)' do
+                    it 'adds the specified user' do
+                        switcher.should_receive(:add).with("John Galt <jgalt@example.com>")
+                        gitsu.go ["-a", "John Galt <jgalt@example.com>"]
+                    end
+                end
+
+                context 'long option (--add)' do
+                    it 'adds the specified user' do
+                        switcher.should_receive(:add).with("John Galt <jgalt@example.com>")
+                        gitsu.go ["--add", "John Galt <jgalt@example.com>"]
+                    end
+                end
+            end
+
+            context 'when "list" option passed' do
+                context 'short option (-t)' do
+                    it 'lists the users' do
+                        switcher.should_receive(:list)
+                        gitsu.go ["-t"]
+                    end
+                end
+
+                context 'long option (--list)' do
+                    it 'lists the users' do
+                        switcher.should_receive(:list)
+                        gitsu.go ["--list"]
+                    end
+                end
+            end
+
+            context 'when "edit" option passed' do
+                context 'short option (-e)' do
+                    it 'edits the Gitsu config file' do
+                        switcher.should_receive(:edit_config)
+                        gitsu.go ["-e"]
+                    end
+                end
+
+                context 'long option (--edit)' do
+                    it 'edits the Gitsu config file' do
+                        switcher.should_receive(:edit_config)
+                        gitsu.go ["--edit"]
+                    end
+                end
+            end
+        end
+    end
+end

data/spec/gitsu/runner_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+module GitSu
+    describe Runner do
+        let(:output) { double('output') }
+        let(:runner) { Runner.new(output) }
+
+        describe "#run" do
+            it "runs the block it's passed" do
+                ran = false
+                runner.run { ran = true }
+                ran.should be true
+            end
+
+            it "catches interruptions" do
+                output.should_receive(:puts).with "Interrupted"
+                runner.run { raise Interrupt }
+            end
+
+            it "prints errors" do
+                output.should_receive(:puts).with "Bad stuff happened"
+                runner.run { raise "Bad stuff happened" }
+            end
+        end
+    end
+end
+

data/spec/gitsu/switcher_spec.rb

@@ -0,0 +1,196 @@
+require 'spec_helper'
+
+module GitSu
+
+    describe Switcher do
+        let(:git) { double('git') }
+        let(:user_list) { double('user_list') }
+        let(:output) { double('output').as_null_object }
+        let(:switcher) { Switcher.new(git, user_list, output) }
+        let(:a_user) { User.new("Johnny Bravo", "jbravo@example.com") }
+
+        describe '#request' do
+            context "when request is a fully-qualified user string (e.g. 'John Galt <jgalt@example.com>'" do
+                it "switches to user" do
+                    user = User.new('John Galt', 'jgalt@example.com')
+                    git.should_receive(:select_user).with(user, :global)
+                    git.should_receive(:render).with(user).and_return(user.to_s)
+                    output.should_receive(:puts).with("Switched global user to John Galt <jgalt@example.com>")
+                    switcher.request('John Galt <jgalt@example.com>', :global)
+                end
+            end
+
+            context "when no matching user found" do
+                it "does not switch user" do
+                    user_list.should_receive(:find).with('asdfasdf').and_return User::NONE
+                    output.should_receive(:puts).with("No user found matching 'asdfasdf'")
+                    switcher.request('asdfasdf', :global)
+                end
+            end
+
+            context "when user is in user list" do
+                it "switches to requested user" do
+                    user = User.new('John Galt', 'jgalt@example.com')
+
+                    user_list.should_receive(:find).with("john").and_return user 
+                    git.should_receive(:select_user).with user, :global
+                    git.should_receive(:render).with(user).and_return user.to_s
+                    output.should_receive(:puts).with("Switched global user to John Galt <jgalt@example.com>")
+                    switcher.request "john", :global
+                end
+            end
+
+            context "when 'default' scope is specified" do
+                it "switches user in configured default scope" do
+                    user = User.new('John Galt', 'jgalt@example.com')
+
+                    user_list.should_receive(:find).with("john").and_return user 
+                    git.should_receive(:default_select_scope).and_return(:global)
+                    git.should_receive(:select_user).with user, :global
+                    git.should_receive(:render).with(user).and_return user.to_s
+                    output.should_receive(:puts).with("Switched global user to John Galt <jgalt@example.com>")
+                    switcher.request "john", :default
+                end
+            end
+        end
+
+        describe '#print_current' do
+            context "when 'all' scope is specified" do
+                it "prints all users" do
+                    local_user = User.new('Johnny Local', 'jlocal@example.com')
+                    global_user = User.new('Johnny Global', 'jglobal@example.com')
+                    system_user = User.new('Johnny System', 'jsystem@example.com')
+                    derived_user = local_user
+
+                    git.should_receive(:render_user).with(:derived).and_return derived_user.to_s
+                    git.should_receive(:render_user).with(:local).and_return local_user.to_s
+                    git.should_receive(:render_user).with(:global).and_return global_user.to_s
+                    git.should_receive(:render_user).with(:system).and_return system_user.to_s
+                    output.should_receive(:puts).with("Current user: Johnny Local <jlocal@example.com>")
+                    output.should_receive(:puts).with("Local: Johnny Local <jlocal@example.com>")
+                    output.should_receive(:puts).with("Global: Johnny Global <jglobal@example.com>")
+                    output.should_receive(:puts).with("System: Johnny System <jsystem@example.com>")
+                    switcher.print_current(:all)
+                end
+            end
+
+            context "when a scope is specified" do
+                context "when there is a user selected" do
+                    it "prints the current user" do
+                        current_user = User.new('John Galt', 'jgalt@example.com')
+                        git.should_receive(:selected_user).with(:global).and_return current_user
+                        git.should_receive(:render_user).with(:global).and_return current_user.to_s
+                        output.should_receive(:puts).with("John Galt <jgalt@example.com>")
+                        switcher.print_current(:global)
+                    end
+                end
+
+                context "when there is no user selected" do
+                    it 'does not print anything' do
+                        git.should_receive(:selected_user).with(:local).and_return User::NONE
+                        switcher.print_current(:local)
+                    end
+                end
+            end
+
+            context "when multiple scopes are specified" do
+                context "when there is a user selected in all scopes" do
+                    it "prints the current user in those scopes" do
+                        local_user = User.new('John Local', 'jl@example.com')
+                        global_user = User.new('John Global', 'jg@example.com')
+                        git.should_receive(:selected_user).with(:local).and_return local_user
+                        git.should_receive(:render_user).with(:local).and_return local_user.to_s
+                        git.should_receive(:selected_user).with(:global).and_return global_user
+                        git.should_receive(:render_user).with(:global).and_return global_user.to_s
+                        output.should_receive(:puts).with("John Local <jl@example.com>")
+                        output.should_receive(:puts).with("John Global <jg@example.com>")
+                        switcher.print_current(:local, :global)
+                    end
+                end
+
+                context "when there is no user selected in one scope" do
+                    it 'prints only users for scopes that have users' do
+                        global_user = User.new('John Global', 'jg@example.com')
+                        git.should_receive(:selected_user).with(:local).and_return User::NONE
+                        git.should_receive(:selected_user).with(:global).and_return global_user
+                        git.should_receive(:render_user).with(:global).and_return global_user.to_s
+                        output.should_receive(:puts).with("John Global <jg@example.com>")
+                        switcher.print_current(:local, :global)
+                    end
+                end
+            end
+        end
+
+        describe '#add' do
+            context "when the user doesn't already exist in the user list" do
+                it "adds the specified user to the user list" do
+                    user_list.should_receive(:list).and_return []
+                    user_list.should_receive(:add).with User.new('John Galt', 'jgalt@example.com')
+                    output.should_receive(:puts).with("User 'John Galt <jgalt@example.com>' added to users")
+                    switcher.add("John Galt <jgalt@example.com>")
+                end
+            end
+            context "when the user already exists in the user list" do
+                it "doesn't add the user to the user list" do
+                    user_list.should_receive(:list).and_return [User.new('John Galt', 'jgalt@example.com')]
+                    output.should_receive(:puts).with("User 'John Galt <jgalt@example.com>' already in user list")
+                    switcher.add("John Galt <jgalt@example.com>")
+                end
+            end
+            context "when the input is not in expected format" do
+                it "prints an error" do
+                    output.should_receive(:puts).with("Couldn't parse 'xxx' as user (expected user in format: 'John Smith <jsmith@example.com>')")
+                    switcher.add("xxx")
+                end
+            end
+        end
+
+        describe '#list' do
+            it "lists the configured users" do
+                users = []
+                users << User.new("User One", "1@example.com")
+                users << User.new("User Two", "2@example.com")
+
+                user_list.should_receive(:list).and_return(users)
+                git.should_receive(:render).with(users.first).and_return(users.first.to_s)
+                output.should_receive(:puts).with("User One <1@example.com>")
+                git.should_receive(:render).with(users.last).and_return(users.last.to_s)
+                output.should_receive(:puts).with("User Two <2@example.com>")
+                switcher.list
+            end
+        end
+
+        describe '#clear' do
+            context "when a scope is specified" do
+                it "clears the current user in the specified scope" do
+                    git.should_receive(:clear_user).with(:local)
+                    switcher.clear :local
+                end
+            end
+            context "when multiple scopes are specified" do
+                it "clears Git users in the specified scopes" do
+                    output.should_receive(:puts).with("Clearing Git users in local and global scopes")
+                    git.should_receive(:clear_user).with(:local)
+                    git.should_receive(:clear_user).with(:global)
+                    switcher.clear :local,:global
+                end
+            end
+            context "when 'all' scope is specified" do
+                it "clears all Git users" do
+                    output.should_receive(:puts).with("Clearing Git users in all scopes")
+                    git.should_receive(:clear_user).with(:local)
+                    git.should_receive(:clear_user).with(:global)
+                    git.should_receive(:clear_user).with(:system)
+                    switcher.clear :all
+                end
+            end
+        end
+
+        describe '#edit_config' do
+            it "tells Git to open the Gitsu config file in an editor" do
+                git.should_receive(:edit_gitsu_config)
+                switcher.edit_config
+            end
+        end
+    end
+end

data/spec/gitsu/user_list_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+require 'yaml'
+
+module GitSu
+    describe UserList do
+
+        let(:user_file) { "/tmp/#{rand}" }
+        let(:user_list) { UserList.new(user_file) }
+        after { File.delete user_file }
+
+        describe "#add" do
+            it "adds a user to the list" do
+                user_list.add User.new("John Galt", "jgalt@example.com")
+
+                user_map = YAML.parse_file(user_file).transform
+                user_map.keys.should include("jgalt@example.com")
+                user_map["jgalt@example.com"].should == "John Galt" 
+            end
+        end
+
+        describe "#list" do
+            context "when there are no users configured" do
+                it "returns an empty array" do
+                    user_list.list.should be_empty
+                end
+            end
+            
+            context "when there are users configured" do
+                it "returns an array of all the users" do
+                    user_list.add User.new("John Galt", "jgalt@example.com")
+
+                    list = user_list.list
+                    list.size.should be 1
+                    list.should include User.new("John Galt", "jgalt@example.com")
+                end
+            end
+        end
+
+        describe "#find" do
+            context "when a matching user exists" do
+                it "returns the matching user by first name" do
+                    user_list.add User.new("John Galt", "jgalt@example.com")
+
+                    user_list.find("john").should == User.new("John Galt", "jgalt@example.com")
+                    user_list.find("John").should == User.new("John Galt", "jgalt@example.com")
+                end
+                it "returns the matching user by email snippet" do
+                    user_list.add User.new("John Galt", "jgalt@example.com")
+
+                    user_list.find("example").should == User.new("John Galt", "jgalt@example.com")
+                end
+                it "returns the matching user by initials" do
+                    user_list.add User.new("John Galt", "john.galt@example.com")
+
+                    user_list.find("jg").should == User.new("John Galt", "john.galt@example.com")
+                    user_list.find("JG").should == User.new("John Galt", "john.galt@example.com")
+                end
+                it "favours prefix over innards" do
+                    user_list.add User.new("Matthew Jackson", "mj@example.com")
+                    user_list.add User.new("Thomas Hickleton", "tom@example.com")
+                    user_list.add User.new("John Smith", "js@example.com")
+
+                    user_list.find("th").should eq User.new("Thomas Hickleton", "tom@example.com")
+                    user_list.find("s").should eq User.new("John Smith", "js@example.com")
+                end
+                it "favours full firstname match over partial one" do
+                    user_list.add User.new("Matthew Jackson", "mj@example.com")
+                    user_list.add User.new("Mat Jackson", "zz@example.com")
+
+                    user_list.find("mat").should eq User.new("Mat Jackson", "zz@example.com")
+                end
+            end
+
+            context "when no matching user exists" do
+                it "returns no user" do
+                    user_list.find("john").should be User::NONE
+                end
+            end
+        end
+    end
+end
+