gitsu 1.0.0 → 2.0.0

data/spec/gitsu/shell_spec.rb

@@ -0,0 +1,55 @@
+# Gitsu
+# Copyright (C) 2013 drrb
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'spec_helper'
+
+module GitSu
+    describe Shell do
+        let(:shell) { Shell.new }
+
+        describe "#capture" do
+            it "executes the command and returns the output" do
+                output = shell.capture 'echo hello'
+                output.should == "hello"
+            end
+            it "calls the supplied block with the exit status and output" do
+                command = 'echo hello && false'
+                block_called = false
+                return_value = shell.capture(command) do |output, result|
+                    block_called = true
+                    output.should == "hello"
+                    result.exitstatus.should be 1
+                end
+                return_value.should == "hello"
+                block_called.should be true
+            end
+        end
+
+        describe "#execute" do
+            context "when a command returns zero" do
+                it "executes the command and returns true" do
+                    shell.execute("true").should be true
+                end
+            end
+            context "when a command returns nonzero" do
+                it "executes the command and returns false" do
+                    shell.execute("false").should be false
+                end
+            end
+        end
+    end
+end
+

data/spec/gitsu/switcher_spec.rb

@@ -1,30 +1,68 @@
+# Gitsu
+# Copyright (C) 2013 drrb
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
 require 'spec_helper'
 
 module GitSu
 
     describe Switcher do
+        let(:config_repository) { double('config_repository') }
         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") }
+        let(:switcher) { Switcher.new(config_repository, git, user_list, output) }
 
         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
+                it "switches to user and adds them" do
                     user = User.new('John Galt', 'jgalt@example.com')
+                    config_repository.should_receive(:group_email_address).and_return("dev@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)
+                    user_list.should_receive(:list).and_return []
+                    user_list.should_receive(:add).with(user)
+                    switcher.request(:global, 'John Galt <jgalt@example.com>')
+                end
+            end
+
+            context "when request is for multiple users" do
+                it "combines users" do
+                    combined_user = User.new('Johnny A, Johnny B and Johnny C', 'dev+a+b+c@example.com')
+                    config_repository.should_receive(:group_email_address).and_return("dev@example.com")
+                    git.should_receive(:select_user).with(combined_user, :global)
+                    git.should_receive(:render).with(combined_user).and_return(combined_user.to_s)
+                    output.should_receive(:puts).with("Switched global user to Johnny A, Johnny B and Johnny C <dev+a+b+c@example.com>")
+                    
+                    # TODO: how do you do times in rspec again?
+                    user_list.should_receive(:list).and_return []
+                    user_list.should_receive(:add).with User.new("Johnny A", "a@example.com")
+                    user_list.should_receive(:list).and_return []
+                    user_list.should_receive(:add).with User.new("Johnny B", "b@example.com")
+                    user_list.should_receive(:list).and_return []
+                    user_list.should_receive(:add).with User.new("Johnny C", "c@example.com")
+                    switcher.request(:global, 'Johnny C <c@example.com>', 'Johnny B <b@example.com>', 'Johnny A <a@example.com>')
                 end
             end
 
-            context "when no matching user found" do
+            context "when at least one user isn't 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)
+                    user_list.should_receive(:find).with('john', 'xx').and_raise "No user found matching 'xx'"
+                    output.should_receive(:puts).with("No user found matching 'xx'")
+                    switcher.request(:global, 'john', 'xx')
                 end
             end
 
@@ -32,11 +70,12 @@ module GitSu
                 it "switches to requested user" do
                     user = User.new('John Galt', 'jgalt@example.com')
 
-                    user_list.should_receive(:find).with("john").and_return user 
+                    user_list.should_receive(:find).with("john").and_return [user ]
+                    config_repository.should_receive(:group_email_address).and_return("dev@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", :global
+                    switcher.request :global, "john" 
                 end
             end
 
@@ -44,12 +83,13 @@ module GitSu
                 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)
+                    user_list.should_receive(:find).with("john").and_return [user ]
+                    config_repository.should_receive(:group_email_address).and_return("dev@example.com")
+                    config_repository.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
+                    switcher.request :default, "john"
                 end
             end
         end

data/spec/gitsu/user_file_spec.rb

@@ -0,0 +1,91 @@
+# Gitsu
+# Copyright (C) 2013 drrb
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'spec_helper'
+require 'yaml'
+require 'fileutils'
+
+module GitSu
+    describe UserFile do
+        let(:user_file_name) { "/tmp/#{rand}" }
+        let(:user_file) { UserFile.new user_file_name }
+
+        after do
+            File.delete user_file_name if File.exist? user_file_name
+        end
+
+        describe "#initialize" do
+            context "when file is missing" do
+                it "creates the file" do
+                    UserFile.new user_file_name
+                    File.should exist user_file_name
+                end
+            end
+            context "when file is empty" do
+                it "writes a newline to the file" do
+                    FileUtils.touch user_file_name
+                    UserFile.new user_file_name
+                    File.read(user_file_name).should == "\n"
+                end
+            end
+            context "otherwise" do
+                it "leaves the file alone" do
+                    File.open(user_file_name, "w") {|f| f << "content" }
+                    UserFile.new user_file_name
+                    File.read(user_file_name).should == "content"
+                end
+            end
+        end
+
+        describe "#write" do
+            it "adds a user to the user file as YAML" do
+                user_file.write User.new("John Galt", "jgalt@example.com")
+
+                user_map = YAML.load_file(user_file_name)
+                user_map.should == { "jgalt@example.com" => "John Galt" }
+            end
+            it "doesn't overwrite existing users" do
+                user_file.write User.new("John Galt", "jgalt@example.com")
+                user_file.write User.new("Joseph Porter", "porter@example.com")
+
+                user_map = YAML.load_file(user_file_name)
+                user_map.should == {
+                    "jgalt@example.com" => "John Galt",
+                    "porter@example.com" => "Joseph Porter"
+                }
+            end
+        end
+
+        describe "#read" do
+            it "parses user file as a list of users" do
+                user_1 = User.new("John Galt", "jgalt@example.com")
+                user_2 = User.new("Joseph Porter", "porter@example.com")
+                user_file.write user_1 
+                user_file.write user_2
+
+                user_map = user_file.read
+                user_map.sort_by {|user| user.name}.should == [ user_1, user_2 ]
+            end
+
+            context "when the file is empty" do
+                it "returns an empty list" do
+                    user_file.read.should == []
+                end
+            end
+        end
+    end
+end
+

data/spec/gitsu/user_list_spec.rb

@@ -1,81 +1,152 @@
+# Gitsu
+# Copyright (C) 2013 drrb
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
 require 'spec_helper'
-require 'yaml'
 
 module GitSu
     describe UserList do
 
-        let(:user_file) { "/tmp/#{rand}" }
+        let(:user_file) { InMemoryUserFile.new }
         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" 
+            it "adds a user to the user file" do
+                user = User.new("John Galt", "jgalt@example.com")
+                user_list.add user
+                user_file.should include user
             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
+            it "reads all users from the user file" do
+                user_file.stub(:read).and_return ["user1", "user2", "user3"]
+                user_list.list.should == ["user1", "user2", "user3"]
             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_file.add("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")
+                    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_file.add("John Galt", "jgalt@example.com")
 
-                    user_list.find("example").should == 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_file.add("John Galt", "john@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")
+                    user_list.find("jg").should == [User.new("John Galt", "john@example.com")]
+                    user_list.find("JG").should == [User.new("John Galt", "john@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_file.add("Matthew Jackson", "mj@example.com")
+                    user_file.add("Thomas Hickleton", "tom@example.com")
+                    user_file.add("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")
+                    user_list.find("th").should == [User.new("Thomas Hickleton", "tom@example.com")]
+                    user_list.find("s").should == [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_file.add("Matthew Jackson", "mj@example.com")
+                    user_file.add("Mat Jackson", "zz@example.com")
 
-                    user_list.find("mat").should eq User.new("Mat Jackson", "zz@example.com")
+                    user_list.find("mat").should == [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
+                it "raises an error" do
+                    expect {user_list.find("john")}.to raise_error "No user found matching 'john'"
                 end
             end
+
+            context "when searching for two strings" do
+                it "returns two users if they both match the search strings" do
+                    user_file.add("Johnny A", "ja@example.com")
+                    user_file.add("Johnny B", "jb@example.com")
+
+                    user_list.find("ja", "jb").should == [
+                        User.new("Johnny A", "ja@example.com"),
+                        User.new("Johnny B", "jb@example.com")
+                    ]
+                end
+                it "returns other matched users when first match already found" do
+                    user_file.add("Johnny A", "ja@example.com")
+                    user_file.add("Johnny B", "jb@example.com")
+
+                    user_list.find("j", "j").should == [
+                        User.new("Johnny A", "ja@example.com"),
+                        User.new("Johnny B", "jb@example.com")
+                    ]
+                end
+
+                context "when no matching user exists for a search term" do
+                    it "raises an error" do
+                        user_file.add("Johnny A", "ja@example.com")
+
+                        expect {user_list.find("ja", "jb")}.to raise_error "No user found matching 'jb'"
+                    end
+                end
+                context "when a search term only matches users that were already matched" do
+                    it "raises an error" do
+                        user_file.add("Johnny A", "ja@example.com")
+                        user_file.add("Johnny B", "jb@example.com")
+
+                        expect {user_list.find("ja", "jb", "j")}.to raise_error "Couldn't find a combination of unique users matching 'ja', 'jb' and 'j'"
+                    end
+                end
+                context "when a search term only matches a user that was already matched, but the matching search term matched multiple users" do
+                    it "adjusts the selection so that both terms match" do
+                        user_file.add("Johnny A", "ja@example.com")
+                        user_file.add("Johnny B", "jb@example.com")
+
+                        user_list.find("j", "ja").sort_by{|u| u.name}.should == [
+                            User.new("Johnny A", "ja@example.com"),
+                            User.new("Johnny B", "jb@example.com")
+                        ]
+                    end
+                end
+            end
+        end
+    end
+
+    class InMemoryUserFile
+        def add(name, email)
+            write User.new(name, email)
+        end
+
+        def users
+            @users ||= []
+        end
+        
+        def read
+            users
+        end
+        
+        def write(user)
+            users << user
+        end
+
+        def include?(user)
+            users.include? user
         end
     end
 end

data/spec/gitsu/user_spec.rb

@@ -1,3 +1,19 @@
+# Gitsu
+# Copyright (C) 2013 drrb
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
 module GitSu
     describe User do
         describe "#parse" do
@@ -23,11 +39,92 @@ module GitSu
             end
         end
 
+        describe "#hash" do
+            it "is different if name is different" do
+                user_a = User.new("a", "a@a.com")
+                user_b = User.new("b", "a@a.com")
+                user_a.hash.should_not == user_b.hash
+            end
+            it "is different if email is different" do
+                user_a = User.new("a", "a@a.com")
+                user_b = User.new("a", "b@a.com")
+                user_a.hash.should_not == user_b.hash
+            end
+            it "is the same if name and email are the same" do
+                user_a = User.new("a", "a@a.com")
+                user_b = User.new("a", "a@a.com")
+                user_a.hash.should == user_b.hash
+            end
+        end
+
         describe "#to_ansi_s" do
             it "returns a colored string representation of the user" do
                 user = User.new("John Galt", "jg@example.com")
                 user.to_ansi_s("\e[34m", "\e[35m", "\e[0m").should == "\e[34mJohn Galt\e[0m \e[35m<jg@example.com>\e[0m"
             end
+
+            context "when called on the null user" do
+                it "returns a colored string representation of the null user" do
+                    user = User::NONE
+                    user.to_ansi_s("\e[34m", "\e[35m", "\e[0m").should == "\e[34m(none)\e[0m"
+                end
+            end
+        end
+
+        describe "#combine" do
+            it "combines the user with the provided other user" do
+                user = User.new("John A", "ja@example.com")
+                other = User.new("John B", "jb@example.com")
+                combined_user = user.combine other, "dev@example.com"
+                combined_user.name.should == "John A and John B"
+                combined_user.email.should == "dev+ja+jb@example.com"
+            end
+            it "accumulates users" do
+                user1 = User.new("John A", "ja@example.com")
+                user2 = User.new("John B", "jb@example.com")
+                user3 = User.new("John C", "jc@example.com")
+                combined_user = user1.combine(user2, "dev@example.com").combine(user3, "dev@example.com")
+                combined_user.name.should == "John A, John B and John C"
+                combined_user.email.should == "dev+ja+jb+jc@example.com"
+            end
+            it "can be called with combined users" do
+                user1 = User.new("John A", "ja@example.com")
+                user2 = User.new("John B", "jb@example.com")
+                user3 = User.new("John C", "jc@example.com")
+                combined_user = user1.combine(user2, "dev@example.com")
+                combined_user = user3.combine(combined_user, "dev@example.com")
+                combined_user.name.should == "John A, John B and John C"
+                combined_user.email.should == "dev+ja+jb+jc@example.com"
+            end
+            it "removes duplicate users by email" do
+                user = User.new("John A", "ja@example.com")
+                other = User.new("John B", "ja@example.com")
+                combined_user = user.combine other, "dev@example.com"
+                combined_user.name.should == "John B"
+                combined_user.email.should == "ja@example.com"
+            end
+            it "sorts combined users by email" do
+                user1 = User.new("John Z", "ja@example.com")
+                user2 = User.new("John X", "jc@example.com")
+                user3 = User.new("John Y", "jb@example.com")
+                combined_user = user1.combine(user2, "dev@example.com").combine(user3, "dev@example.com")
+                combined_user.name.should == "John Z, John Y and John X"
+                combined_user.email.should == "dev+ja+jb+jc@example.com"
+            end
+            it "doesn't have side-effects" do
+                ja = User.new("John A", "ja@example.com")
+                jb = User.new("John B", "jb@example.com")
+                combined_user = ja.combine(jb, "dev@example.com")
+                ja.name.should == "John A"
+                ja.email.should == "ja@example.com"
+            end
+            context "when combined with NONE" do
+                it "returns a clone of itself" do
+                    ja = User.new("John A", "ja@example.com")
+                    ja.combine(User::NONE, "dev@example.com").should == ja
+                    User::NONE.combine(ja, "dev@example.com").should == ja
+                end
+            end
         end
     end
 end