minglr 1.3.11

data/test/config_parser_test.rb

@@ -0,0 +1,116 @@
+require 'test_helper'
+
+module Minglr
+  
+  class ConfigParserTest < Test::Unit::TestCase
+    
+    context "parse" do
+    
+      should "look for a config file in the user home directory or the current working directory" do
+        File.expects(:exist?).with(File.join(ENV["HOME"], ".minglrconfig")).returns(true)
+        #File.expects(:exist?).with(File.expand_path(File.join(ENV["PWD"], ".minglrconfig"))).returns(false)
+        config_file_contents = ""
+        File.expects(:read).with(File.join(ENV["HOME"], ".minglrconfig")).returns(config_file_contents)
+        
+        ConfigParser.parse
+      end
+      
+      should "return the parsed configuration as a hash" do
+        configuration_content = <<-EOS
+          [foo]
+            myfoo = myvalue
+          [bar]
+            mybar = yourvalue
+        EOS
+        
+        File.stubs(:exist?).returns(true)
+        File.expects(:read).returns(configuration_content)
+        parsed_configuration = ConfigParser.parse
+        
+        assert_equal Hash, parsed_configuration.class
+      end
+      
+      should "print a message if the config file cannot be found" do
+        File.expects(:exist?).times(2).returns(false)
+        ConfigParser.expects(:class_eval).with("send :exit, 1")
+        ConfigParser.expects(:puts)
+        ConfigParser.parse
+      end
+    
+    end
+    
+    context "initialize" do
+      
+      should "parse the configuration file into sections and variables" do
+        configuration_content = <<-EOS
+          [foo]
+            myfoo = myvalue
+          [bar]
+            mybar = yourvalue
+        EOS
+        
+        parsed_configuration = ConfigParser.new(configuration_content)
+        assert_equal true, parsed_configuration.config.has_key?(:foo)
+        assert_equal true, parsed_configuration.config.has_key?(:bar)
+        assert_equal true, parsed_configuration.config[:foo].has_key?(:myfoo)
+        assert_equal true, parsed_configuration.config[:bar].has_key?(:mybar)
+        assert_equal "myvalue", parsed_configuration.config[:foo][:myfoo]
+        assert_equal "yourvalue", parsed_configuration.config[:bar][:mybar]
+      end
+      
+      should "skip comment lines" do
+        configuration_content = <<-EOS
+          # [foo]
+          #   bar = bad
+          [foo]
+            bar = baz
+        EOS
+        
+        parsed_configuration = ConfigParser.new(configuration_content)
+        assert_equal "baz", parsed_configuration.config[:foo][:bar]
+      end
+      
+      should "skip blank lines" do
+        configuration_content = <<-EOS
+
+          [foo]
+          
+          [babble]
+            bar = baz
+        EOS
+        
+        parsed_configuration = ConfigParser.new(configuration_content)
+        assert_equal "baz", parsed_configuration.config[:babble][:bar]
+      end
+      
+      should "not redefine a section if it has already been defined" do
+        configuration_content = <<-EOS
+          [foo]
+            bar = baz
+            should = bekept
+            
+          [foo]
+            bar = somethingelse
+        EOS
+        
+        parsed_configuration = ConfigParser.new(configuration_content)
+        assert_equal "somethingelse", parsed_configuration.config[:foo][:bar]
+        assert_equal "bekept", parsed_configuration.config[:foo][:should]
+      end
+      
+      should "set a section variable to the latest value allowing it to be redefined" do
+        configuration_content = <<-EOS
+          [foo]
+            bar = baz
+            bar = somethingelse
+        EOS
+        
+        parsed_configuration = ConfigParser.new(configuration_content)
+        assert_equal "somethingelse", parsed_configuration.config[:foo][:bar]
+      end
+      
+    end
+    
+  end
+  
+end

data/test/extensions/array_test.rb

@@ -0,0 +1,41 @@
+require 'test_helper'
+
+module Minglr
+  module Extensions
+  
+    class ArrayTest < Test::Unit::TestCase
+
+      context Array do
+    
+        context "filter" do
+          
+          setup do
+            class TestObject
+              attr_accessor :name
+            end
+            @test1 = TestObject.new
+            @test2 = TestObject.new
+            @test1.name = "test1"
+            @test2.name = "test2"
+            @collection = [@test1, @test2]
+            @collection.send(:extend, Minglr::Extensions::Array)
+          end
+          
+          should "include elements matching words in attributes" do
+            assert_equal [@test1], @collection.filter([:name], ["1"])
+            assert_equal [@test1, @test2], @collection.filter([:name], ["test"])
+          end
+
+          should "deal with empty words and attributes" do
+            assert_equal [@test1, @test2], @collection.filter([], [])
+            assert_equal [@test1, @test2], @collection.filter([:name], [])
+            assert_equal [], @collection.filter([], ["1"])
+          end
+    
+        end
+    
+      end
+
+    end
+  end
+end

data/test/options_parser_test.rb

@@ -0,0 +1,74 @@
+require 'test_helper'
+
+module Minglr
+  
+  class OptionsParserTest < Test::Unit::TestCase
+    
+    context "parse" do
+      
+      should "gather all property definitions for a given project" do
+        Resources::Base.site = "http://foo.bar"
+        Resources::PropertyDefinition.expects(:project_options).returns([[:column_name, "Some Column Name"]])
+        OptionsParser.expects(:puts)
+        OptionsParser.parse(["--version"])
+      end
+      
+      should "warn about authentication if property definition gathering fails" do
+        Resources::Base.site = "http://foo.bar"
+        Resources::PropertyDefinition.expects(:project_options).raises(ActiveResource::UnauthorizedAccess, stub(:code => "BadAccess"))
+        OptionsParser.expects(:puts).at_least(1)
+        OptionsParser.expects(:puts).with("Connection Failed with BadAccess  to http://foo.bar")
+        OptionsParser.expects(:puts).with("Did you set 'basic_authentication_enabled: true' in your auth_config.yml file?")
+        OptionsParser.parse(["--version"])
+      end
+      
+      should "parse name option" do
+        Resources::Base.site = "http://foo.bar"
+        Resources::PropertyDefinition.stubs(:project_options).returns([])
+        options = OptionsParser.parse(["-n", "MyName"])
+        
+        assert_equal true, options.has_key?(:name)
+        assert_equal "MyName", options[:name]
+      end
+      
+      should "parse description option" do
+        Resources::Base.site = "http://foo.bar"
+        Resources::PropertyDefinition.stubs(:project_options).returns([])
+        options = OptionsParser.parse(["-d", "MyDescription"])
+        
+        assert_equal true, options.has_key?(:description)
+        assert_equal "MyDescription", options[:description]
+      end
+      
+      should "parse type option" do
+        Resources::Base.site = "http://foo.bar"
+        Resources::PropertyDefinition.stubs(:project_options).returns([])
+        options = OptionsParser.parse(["-t MyType"])
+        
+        assert_equal true, options.has_key?(:card_type_name)
+        assert_equal "MyType", options[:card_type_name]
+      end
+      
+      should "parse comment option" do
+        Resources::Base.site = "http://foo.bar"
+        Resources::PropertyDefinition.stubs(:project_options).returns([])
+        options = OptionsParser.parse(["-c MyComment"])
+        
+        assert_equal true, options.has_key?(:comment)
+        assert_equal "MyComment", options[:comment]
+      end
+      
+      should "parse file option" do
+        Resources::Base.site = "http://foo.bar"
+        Resources::PropertyDefinition.stubs(:project_options).returns([])
+        options = OptionsParser.parse(["-f MyFile"])
+        
+        assert_equal true, options.has_key?(:file_attachment)
+        assert_equal "MyFile", options[:file_attachment]
+      end
+      
+    end
+    
+  end
+  
+end

data/test/resources/attachment_test.rb

@@ -0,0 +1,90 @@
+require 'test_helper'
+
+module Resources
+  
+  class AttachmentTest < Test::Unit::TestCase
+  
+    context Attachment do
+
+      context "configure" do
+        
+        should "append to the site url" do
+          options = { :username => "user",
+                      :password => "pass",
+                      :url => "proto://somehost.com:1234/projects/my_project" }
+          Base.configure(options)
+          Attachment.configure
+          assert_equal  "/projects/my_project/cards/1/", Attachment.prefix(:card_number => 1)
+        end
+      
+      end
+      
+      context "fetch" do
+        
+        should "download all found attachments for a given card number" do
+          card = Card.new
+          card.stubs(:number).returns(1)
+          
+          attachment1 = Attachment.new
+          attachment1.stubs(:url).returns("http://attachment1.url")
+          attachment1.stubs(:file_name).returns("attachment1.txt")
+          attachment2 = Attachment.new
+          attachment2.stubs(:url).returns("http://attachment2.url")
+          attachment2.stubs(:file_name).returns("attachment2.txt")
+
+          Attachment.stubs(:puts)
+          Card.expects(:find).with(1).returns(card)
+          Attachment.expects(:find).with(:all, :params => { :card_number => 1 }).returns([attachment1, attachment2])
+          Attachment.expects(:curl).with("curl --insecure --progress-bar --output attachment1.txt --user username:password http://attachment1.url")
+          Attachment.expects(:curl).with("curl --insecure --progress-bar --output attachment2.txt --user username:password http://attachment2.url")
+          
+          Attachment.fetch(1, "username", "password")
+        end
+      
+      end
+      
+      context "attach" do
+        
+        setup do
+          options = { :username => "user",
+                      :password => "pass",
+                      :url => "proto://somehost.com:1234/projects/my_project" }
+          Base.configure(options)
+        end
+        
+        should "upload file for a given card number" do
+          file_name = File.join(File.dirname(__FILE__), "..", "..", "Rakefile")
+          
+          card = Card.new
+          card.stubs(:number).returns(1)
+          
+          fake_response = stub("Response", :status_code => 201)
+          fake_client = mock("HTTPClient")
+          fake_client.expects(:post).returns(fake_response)
+          fake_client.expects(:set_auth).with(nil, "username", "password")
+          
+          Card.expects(:find).with(1).returns(card)
+          HTTPClient.expects(:new).returns(fake_client)
+          Attachment.expects(:puts).with("File '#{file_name}' attached to card 1")
+
+          Attachment.attach(1, file_name, "username", "password")
+        end
+        
+        should "warn for invalid file" do          
+          card = Card.new
+          card.stubs(:number).returns(1)
+          
+          Card.expects(:find).with(1).returns(card)
+          File.expects(:exist?).with("myfile.txt").returns(false)
+          Attachment.expects(:warn).with("Unable to open file 'myfile.txt'")
+          
+          Attachment.attach(1, "myfile.txt", "username", "password")
+        end
+      
+      end
+    
+    end
+
+  end
+  
+end

data/test/resources/base_test.rb

@@ -0,0 +1,58 @@
+require 'test_helper'
+
+module Resources
+  
+  class BaseTest < Test::Unit::TestCase
+  
+    context Base do
+    
+      context "configure" do
+      
+        should "combine options to build url" do
+          options = { :username => "user",
+                      :password => "pass",
+                      :url => "proto://somehost.com:1234/projects/my_project" }
+          Base.configure(options)
+          assert_equal  "proto://user:pass@somehost.com:1234/projects/my_project",
+                        Base.site.to_s
+        end
+    
+      end
+      
+      context "warn" do
+        
+        should "prepend message with warning" do
+          Base.expects(:puts).with("Warning: test")
+          Base.warn("test")
+        end
+      
+      end
+      
+      context "print_collection" do
+        
+        setup do
+          @object1 = stub("Object", :name => "Foo", :description => "Bar")
+          @object2 = stub("Object", :name => "Bar", :description => "Frobble")
+          @collection = [@object1, @object2]
+          @attributes = [:name, :description]
+        end
+        
+        should "print values of attributes of objects separated by dashes and aligning columns of values" do
+          Base.expects(:puts).with("Foo - Bar    ")
+          Base.expects(:puts).with("Bar - Frobble")
+          Base.print_collection(@collection, @attributes)
+        end
+        
+        should "allow for right adjusted values" do
+          Base.expects(:puts).with("Foo -     Bar")
+          Base.expects(:puts).with("Bar - Frobble")
+          Base.print_collection(@collection, @attributes, :right)
+        end
+        
+      end
+      
+    end
+
+  end
+
+end

data/test/resources/card_test.rb

@@ -0,0 +1,199 @@
+require 'test_helper'
+
+module Resources
+  
+  class CardTest < Test::Unit::TestCase
+  
+    context Card do
+
+      context "create" do
+        
+        should "create a card with options passed in" do
+          card = Card.new
+          card.stubs(:number).returns(1)
+          Card.expects(:new).with(:name => "Name").returns(card)
+          Card.any_instance.expects(:save).returns(true)
+          Card.any_instance.expects(:reload)
+          Card.expects(:puts).with("Card #1 created")
+          Card.create({:name => "Name"})
+        end
+        
+        should "create a card with the status of new if status property is available" do
+          card = Card.new
+          card.stubs(:number).returns(1)
+          Card.expects(:new).with(:some_option => "value", :cp_status => "New").returns(card)
+          Card.any_instance.expects(:save).returns(true)
+          Card.any_instance.expects(:reload)
+          Card.expects(:puts).with("Card #1 created")
+          Card.create({:some_option => "value"}, "cp_status")
+        end
+        
+        should "warn if it is unable to create the card" do
+          Card.any_instance.expects(:save).returns(false)
+          Card.expects(:warn).with("Unable to create card")
+          Card.create
+        end
+        
+      end
+      
+      context "move" do
+        
+        should "move card from one state to the next as defined" do
+          card = Card.new
+          card.stubs(:card_type_name).returns("story")
+          card.stubs(:status).returns("New")
+          config = { :story_state_1 => "New > Dev", :status_property => "status"}
+          response = stub("Response", :attributes => { "status" => "completed" })
+          
+          Card.expects(:find).with(1).returns(card)
+          TransitionExecution.expects(:create).with(:transition => 'Dev', :card => 1).returns(response)
+          Card.expects(:puts).with("Moved card from New to Dev")
+          Card.move(1, {}, config)
+        end
+        
+        should "warn if no matching card type is found" do
+          card = Card.new
+          card.stubs(:card_type_name).returns("someothertype")
+          card.stubs(:status).returns("New")
+          config = { :story_state_1 => "New > Dev", :status_property => "status"}
+          
+          Card.expects(:find).with(1).returns(card)
+          Card.expects(:warn).with("No transitions defined for card of type someothertype")
+          Card.move(1, {}, config)
+        end
+        
+        should "warn if card has no status property" do
+          card = Card.new
+          card.stubs(:card_type_name).returns("story")
+          card.stubs(:current_status).returns("New")
+          config = { :story_state_1 => "New > Dev"}
+          
+          Card.expects(:find).with(1).returns(card)
+          Card.expects(:warn).with("No known status of card #1, cannot move!")
+          Card.move(1, {}, config)
+        end
+        
+        should "warn if card cannot be found" do
+          Card.expects(:find).with(0).returns(nil)
+          Card.expects(:warn).with("No card #0 found to move")
+          Card.move(0)
+        end
+        
+      end
+      
+      context "print_all" do
+        
+        should "warn if there are no cards" do
+          Card.expects(:find).with(:all).returns([])
+          Card.expects(:warn).with("No cards found")
+          Card.print_all
+        end
+        
+        should "print the cards found with format" do
+          card1 = stub("Card", :number => 1, :card_type_name => "Story", :name => "Some Story")
+          card2 = stub("Card", :number => 2, :card_type_name => "Task", :name => "Some Task")
+          Card.expects(:find).with(:all).returns([card1, card2])
+          Card.expects(:puts).with("1 - Story - Some Story")
+          Card.expects(:puts).with("2 - Task  - Some Task ")
+          Card.print_all
+        end
+        
+        should "print cards with status property if available" do
+          card1 = stub("Card", :number => 1, :card_type_name => "Story", :name => "Some Story", :cp_status => "Ready")
+          Card.expects(:find).with(:all).returns([card1])
+          Card.expects(:puts).with("1 - Story - Ready - Some Story")
+          Card.print_all([], "cp_status")
+        end
+      
+      end
+      
+      context "print_card" do
+        
+        should "print the details for a given card" do
+          status_property = "cp_status"
+          card = Card.new
+          card.expects(:to_s).with(status_property)
+          Card.expects(:find).with(1).returns(card)
+          Card.stubs(:puts)
+          Card.print_card(1, status_property)
+        end
+        
+        should "warn if it is not able to find the card" do
+          Card.expects(:find).with(0).returns(nil)
+          Card.expects(:warn).with("No card #0 found")
+          Card.print_card(0)
+        end
+        
+      end
+      
+      context "update" do
+        
+        should "update a card with the options passed in" do
+          card = mock("Card")
+          card.stubs(:number).returns(1)
+          card.expects(:foo=).with("bar")
+          card.expects(:baz=).with("frobble")
+          card.expects(:save)
+          Card.stubs(:puts)
+          Card.expects(:find).with(1).returns(card)
+          
+          Card.update(1, {:foo => "bar", :baz => "frobble"})
+        end
+        
+        should "print out the details of the card after updating" do
+          card = mock("Card")
+          card.stubs(:number).returns(1)
+          card.stubs(:foo=)
+          card.stubs(:baz=)
+          card.stubs(:save)
+          Card.stubs(:find).with(1).returns(card)
+          
+          Card.expects(:puts).with("Card #1 updated\n\n")
+          Card.expects(:puts).with(card.to_s)          
+          Card.update(1, {:foo => "bar", :baz => "frobble"})
+        end
+        
+        should "warn if it is not able to find the card" do
+          Card.expects(:find).with(0).returns(nil)
+          Card.expects(:warn).with("Unable to update card #0")
+          Card.update(0)
+        end
+        
+      end
+      
+      context "to_s" do
+        
+        should "format the details of a given card including attachments" do
+          Resources::Base.site = "http://foo.bar"
+          
+          attachment = Attachment.new
+          attachment.stubs(:file_name).returns("My File Name")
+          attachment.stubs(:url).returns("http://some.url")
+          Attachment.expects(:find).with(:all, :params => { :card_number => 1 }).returns([attachment])
+          
+          card = Card.new
+          card.stubs(:number).returns(1)
+          card.stubs(:name).returns("My Name")
+          card.stubs(:card_type_name).returns("My Type")
+          card.stubs(:description).returns("My Description")
+          
+          expected_output = <<-EOS
+     Number: 1
+       Name: My Name
+       Type: My Type
+     Status: 
+Description: My Description
+
+Attachments:
+  * My File Name: http://some.url
+          EOS
+          assert_equal expected_output, card.to_s
+        end
+        
+      end
+    
+    end
+
+  end
+  
+end