gritano 0.5.3 → 0.5.4

data/Gemfile.lock

@@ -1,27 +1,27 @@
 GEM
   remote: http://rubygems.org/
   specs:
-    activemodel (3.2.8)
-      activesupport (= 3.2.8)
+    activemodel (3.2.11)
+      activesupport (= 3.2.11)
       builder (~> 3.0.0)
-    activerecord (3.2.8)
-      activemodel (= 3.2.8)
-      activesupport (= 3.2.8)
+    activerecord (3.2.11)
+      activemodel (= 3.2.11)
+      activesupport (= 3.2.11)
       arel (~> 3.0.2)
       tzinfo (~> 0.3.29)
-    activesupport (3.2.8)
+    activesupport (3.2.11)
       i18n (~> 0.6)
       multi_json (~> 1.0)
     arel (3.0.2)
-    builder (3.0.2)
+    builder (3.0.4)
     cucumber (1.2.1)
       builder (>= 2.1.2)
       diff-lcs (>= 1.1.3)
       gherkin (~> 2.11.0)
       json (>= 1.4.6)
-    database_cleaner (0.8.0)
+    database_cleaner (0.9.1)
     diff-lcs (1.1.3)
-    gherkin (2.11.2)
+    gherkin (2.11.5)
       json (>= 1.4.6)
     git (1.2.5)
     grit (2.5.0)
@@ -34,28 +34,28 @@ GEM
       git (>= 1.2.5)
       rake
       rdoc
-    json (1.7.5)
+    json (1.7.6)
     mime-types (1.19)
-    multi_json (1.3.6)
+    multi_json (1.5.0)
     posix-spawn (0.3.6)
-    rake (0.9.2.2)
+    rake (10.0.3)
     rdoc (3.12)
       json (~> 1.4)
-    rspec (2.11.0)
-      rspec-core (~> 2.11.0)
-      rspec-expectations (~> 2.11.0)
-      rspec-mocks (~> 2.11.0)
-    rspec-core (2.11.1)
-    rspec-expectations (2.11.3)
+    rspec (2.12.0)
+      rspec-core (~> 2.12.0)
+      rspec-expectations (~> 2.12.0)
+      rspec-mocks (~> 2.12.0)
+    rspec-core (2.12.2)
+    rspec-expectations (2.12.1)
       diff-lcs (~> 1.1.3)
-    rspec-mocks (2.11.2)
-    simplecov (0.6.4)
+    rspec-mocks (2.12.2)
+    simplecov (0.7.1)
       multi_json (~> 1.0)
-      simplecov-html (~> 0.5.3)
-    simplecov-html (0.5.3)
-    sqlite3 (1.3.6)
+      simplecov-html (~> 0.7.1)
+    simplecov-html (0.7.1)
+    sqlite3 (1.3.7)
     terminal-table (1.4.5)
-    tzinfo (0.3.33)
+    tzinfo (0.3.35)
 
 PLATFORMS
   ruby

data/README.rdoc

@@ -71,19 +71,19 @@ For more information, execute
 
 Starting from Gritano 0.3.0, administrators can execute commands via ssh:
 
-  $ ssh git@hot.com admin:user:add username
+  $ ssh git@host.com admin:user:add username
   
-  $ ssh git@hot.com admin:user:rm username
+  $ ssh git@host.com admin:user:rm username
   
-  $ ssh git@hot.com admin:user:key:add username keyname < key.pub
+  $ ssh git@host.com admin:user:key:add username keyname < key.pub
   
-  $ ssh git@hot.com admin:user:key:rm username keyname
+  $ ssh git@host.com admin:user:key:rm username keyname
   
-  $ ssh git@hot.com admin:repo:add reponame.git
+  $ ssh git@host.com admin:repo:add reponame.git
   
-  $ ssh git@hot.com admin:repo:rm reponame.git
+  $ ssh git@host.com admin:repo:rm reponame.git
   
-  $ ssh git@hot.com admin:repo:list
+  $ ssh git@host.com admin:repo:list
   
 == For more Information
 

data/TODO

@@ -1,7 +1,7 @@
 v0.6.0
 - melhorar o instalador/updater
   - escolha de db
-  - escolha de pasta dos repos
+  gritano setup:prepare -db sqlite
   
 v0.7.0
 - gritano-openssh

data/VERSION

@@ -1 +1 @@
-0.5.3
+0.5.4

data/features/data/remote_help.txt

@@ -0,0 +1,13 @@
+  gritano [command]
+
+  Examples:
+  gritano version 
+  gritano help 
+  gritano repo:list 
+  gritano key:list 
+  gritano key:add keyname < key.pub
+  gritano key:rm keyname
+  gritano admin:help 
+
+  --
+  v{{VERSION}}

data/features/step_definitions/install_step.rb

@@ -1,7 +1,7 @@
 Given /^I start the gritano console but gritano is not installed$/ do
   stdin = double()
   stdin.stub(:read).and_return("Your SSHKEY here...")
-  FileUtils.rm_rf('tmp\.gritano')
+  FileUtils.rm_rf('tmp/.gritano')
   @home_dir = 'tmp'
   @repo_dir = 'tmp'
   @console = Gritano::CLI
@@ -21,7 +21,7 @@ When /^I install it$/ do
 end
 
 Then /^I should see that gritano was successful (installed|updated)$/ do |opt|
-  @prepare_output.should be == 'configuration has been generated' if opt == 'installed'
+  @prepare_output.should be == "Gritano's configuration has been generated.\nIf you want to customize it, check your '#{File.join(@home_dir, '.gritano')}' directory." if opt == 'installed'
   @install_output.should be == 'gritano has been installed'
 end
 

data/gritano.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "gritano"
-  s.version = "0.5.3"
+  s.version = "0.5.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Igor Bonadio"]
-  s.date = "2013-01-03"
+  s.date = "2013-01-28"
   s.description = "Gritano is the simplest way to configure your git server over ssh. You can create repositories and manage user access."
   s.email = "igorbonadio@gmail.com"
   s.executables = ["gritano", "gritano-remote"]
@@ -170,6 +170,7 @@ Gem::Specification.new do |s|
     "features/data/remote_commands/repo_list_jessicaeto.txt",
     "features/data/remote_commands/version_igorbonadio.txt",
     "features/data/remote_commands/version_jessicaeto.txt",
+    "features/data/remote_help.txt",
     "features/install.feature",
     "features/local.feature",
     "features/remote.feature",
@@ -193,10 +194,16 @@ Gem::Specification.new do |s|
     "lib/gritano/models/permission.rb",
     "lib/gritano/models/repository.rb",
     "lib/gritano/models/user.rb",
-    "spec/executor_spec.rb",
-    "spec/gritano_spec.rb",
-    "spec/installer_spec.rb",
+    "spec/cli_spec.rb",
+    "spec/console_base_spec.rb",
+    "spec/console_executor_spec.rb",
+    "spec/console_gritano_spec.rb",
+    "spec/console_installer_spec.rb",
+    "spec/console_remote_spec.rb",
+    "spec/console_spec.rb",
+    "spec/data/help_command_name.txt",
     "spec/model_key_spec.rb",
+    "spec/model_permission_spec.rb",
     "spec/model_repository_spec.rb",
     "spec/model_user_spec.rb",
     "spec/spec_helper.rb"

data/lib/gritano/console/base.rb

@@ -61,11 +61,15 @@ module Gritano
       end
 
       def check_git
-        if `which git` == ""
+        if unknown_command('git')
           puts "Error: git must be installed on the local system"
           exit
         end
       end
+      
+      def unknown_command(command)
+        `which #{command}` == ""
+      end
 
       def before_each_command_filter
       end

data/lib/gritano/console/gritano.rb

@@ -23,7 +23,7 @@ module Gritano
       def method_missing(meth, *args, &block)
         params = [meth.to_s.gsub("_", ":")] + args[0]
         begin
-          installer = Installer.new
+          installer = Installer.new(@stdin, @home_dir)
           installer.execute(params)
         rescue
           executor = Executor.new(@stdin, @home_dir, @repo_path)

data/lib/gritano/console/installer.rb

@@ -13,25 +13,41 @@ module Gritano
         check_git
       end
 
-      add_command "setup:prepare" do |argv|
+      def create_gritano_dirs
         Dir.mkdir(File.join(@home_dir, '.gritano')) unless File.exist?(File.join(@home_dir, '.gritano'))
         Dir.mkdir(File.join(@home_dir, '.ssh')) unless File.exist?(File.join(@home_dir, '.ssh'))
+      end
+      
+      def create_sqlite_config
         File.open(File.join(@home_dir, '.gritano', 'database.yml'), "w") do |f|
           f.write("adapter: sqlite3\ndatabase: #{File.join(Etc.getpwuid.dir, '.gritano', 'database.db')}\n")
         end
         if File.exist?(File.join(@home_dir, '.gritano', 'database.db'))
           FileUtils.rm(File.join(@home_dir, '.gritano', 'database.db'))
         end
-        return [true, "configuration has been generated"]
+      end
+      
+      add_command "setup:prepare" do |argv|
+        create_gritano_dirs
+        create_sqlite_config
+        return [true, "Gritano's configuration has been generated.\nIf you want to customize it, check your '#{File.join(@home_dir, '.gritano')}' directory."]
       end
 
-      add_command "setup:install" do |argv|
-        ActiveRecord::Base.establish_connection(
-          YAML::load(File.open(File.join(@home_dir, '.gritano', 'database.yml'))))
+      def create_database
+        db_config = YAML::load(File.open(File.join(@home_dir, '.gritano', 'database.yml')))
+        ActiveRecord::Base.establish_connection(db_config)
         ActiveRecord::Migrator.migrate(
           File.join(File.dirname(__FILE__),'..', '..', '..', 'db/migrate'), 
           ENV["VERSION"] ? ENV["VERSION"].to_i : nil )
+      end
+      
+      def create_authorization_keys
         File.open(File.join(@ssh_path, 'authorized_keys'), 'w').write(Key.authorized_keys)
+      end
+      
+      add_command "setup:install" do |argv|
+        create_database
+        create_authorization_keys
         [true, "gritano has been installed"]
       end
     end

data/lib/gritano/console/remote.rb

@@ -52,28 +52,38 @@ module Gritano
         gritano.execute(["help"])
       end
       
+      def admin_command(meth, params)
+        @executor.execute([meth] + params)
+      end
+      
+      def git_receive_pack(repo, login)
+        user = ::Gritano::User.find_by_login(login)
+        if user
+          Kernel.exec "git-receive-pack #{repo(repo).full_path}" if user.check_access(repo(repo), :read)
+        end
+      end
+      
+      def git_upload_pack(repo, login)
+        user = ::Gritano::User.find_by_login(login)
+        if user
+          Kernel.exec "git-upload-pack #{repo(repo).full_path}" if user.check_access(repo(repo), :write)
+        end
+      end
+      
       def method_missing(meth, *args, &block)
         if meth.to_s =~ /^admin/
           user = ::Gritano::User.find_by_login(args[0][-1])
           if user.admin?
-            meth = meth.to_s[6..-1]
-            params = args[0][0..-2]
-            @executor.execute([meth] + params)
+            admin_command(meth.to_s[6..-1], args[0][0..-2])
           else
             [false, "access denied"]
           end
         elsif meth.to_s =~ /^git-receive-pack/
           repo, login = args[0]
-          user = ::Gritano::User.find_by_login(login)
-          if user
-            Kernel.exec "git-receive-pack #{repo(repo).full_path}" if user.check_access(repo(repo), :read)
-          end
+          git_receive_pack(repo, login)
         elsif meth.to_s =~ /^git-upload-pack/
           repo, login = args[0]
-          user = ::Gritano::User.find_by_login(login)
-          if user
-            Kernel.exec "git-upload-pack #{repo(repo).full_path}" if user.check_access(repo(repo), :write)
-          end
+          git_upload_pack(repo, login)
         else
           super
         end

data/spec/cli_spec.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+module Gritano
+  describe CLI do
+    it "should execute local commands" do
+      console = double()
+      console.should_receive(:execute).and_return([true, "ok"])
+      Gritano::Console.should_receive(:remote_console).with(false)
+      Gritano::Console::Gritano.should_receive(:new).and_return(console)
+      CLI.execute(["user:list"])
+    end
+    
+    it "should execute remote commands" do
+      console = double()
+      console.should_receive(:execute).and_return([true, "ok"])
+      Gritano::Console.should_receive(:remote_console).with(true)
+      Gritano::Console::Remote.should_receive(:new).and_return(console)
+      CLI.check(["repo:list"], "login")
+    end
+  end
+end

data/spec/console_base_spec.rb

@@ -0,0 +1,61 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+module Gritano
+  module Console
+    describe Base do
+      def create_base(home)
+        stdin = double()
+        stdin.stub(:read).and_return("Your SSHKEY here...")
+        Base.new(stdin, home)
+      end
+      
+      it "should define commands" do
+        Base.should_receive(:define_method).with("command_name")
+        Base.add_command "command:name", "parameters" do end
+      end
+      
+      it "should execute commands" do
+        Base.add_command "command:name", "parameters" do end
+        base = create_base('.')
+        base.should_receive('command_name')
+        base.execute(['command:name'])
+      end
+      
+      it "should show a help message" do
+        Base.add_command "command:name", "parameters" do end
+        Base.help.should == File.open("spec/data/help_command_name.txt").readlines.join.
+            gsub('{{VERSION}}', File.open("VERSION").readlines.join)
+      end
+      
+      it "should check if gritano is not installed" do
+        FileUtils.rm_rf('tmp\.gritano')
+        base = create_base('tmp')
+        lambda { base.check_gritano }.should raise_error SystemExit
+      end
+      
+      it "should check if gritano is installed" do
+        base = create_base('.')
+        lambda { base.check_gritano }.should_not raise_error SystemExit
+      end
+      
+      it "should check if git is not installed" do
+        base = create_base('.')
+        base.stub(:unknown_command).and_return(true)
+        lambda { base.check_git }.should raise_error SystemExit
+      end
+      
+      it "should check if git is installed" do
+        base = create_base('.')
+        base.stub(:unknown_command).and_return(false)
+        lambda { base.check_git }.should_not raise_error SystemExit
+      end
+      
+      it "should check if a command exists" do
+        base = create_base('.')
+        base.unknown_command('ls').should be_false
+        base.unknown_command('qwertyuioplkjhgfdsa').should be_true
+      end
+      
+    end
+  end
+end

data/spec/console_executor_spec.rb

@@ -0,0 +1,168 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+module Gritano
+  module Console
+    describe Executor do
+      def create_executor(home, repo_dir)
+        stdin = double()
+        stdin.stub(:read).and_return("Your SSHKEY here...")
+        Executor.new(stdin, home, repo_dir)
+      end
+      
+      it "should list users" do
+        User.should_receive(:all).and_return([])
+        create_executor('.', 'tmp').execute(["user:list"])
+      end
+      
+      it "should list users' keys" do
+        user = double()
+        user.should_receive(:keys).and_return([])
+        User.should_receive(:find_by_login).with("login").and_return(user)
+        create_executor('.', 'tmp').execute(["user:key:list", "login"])
+      end
+      
+      it "should list users' repos" do
+        user = double()
+        user.should_receive(:repositories).and_return([])
+        User.should_receive(:find_by_login).with("login").and_return(user)
+        create_executor('.', 'tmp').execute(["user:repo:list", "login"])
+      end
+      
+      it "should add users" do
+        user = double()
+        user.should_receive(:save).and_return(true)
+        User.should_receive(:new).with(login: "login").and_return(user)
+        create_executor('.', 'tmp').execute(["user:add", "login"])
+      end
+      
+      it "should remove users" do
+        user = double()
+        user.should_receive(:destroy).and_return(true)
+        User.should_receive(:find_by_login).with("login").and_return(user)
+        create_executor('.', 'tmp').execute(["user:rm", "login"])
+      end
+      
+      it "should add users' keys" do
+        user = double()
+        keys = double()
+        key = double()
+        key.should_receive(:valid?).and_return(true)
+        keys.should_receive(:create).with(name: "keyname", key: "Your SSHKEY here...").and_return(key)
+        user.should_receive(:keys).and_return(keys)
+        User.should_receive(:find_by_login).with("login").and_return(user)
+        create_executor('.', 'tmp').execute(["user:key:add", "login", "keyname"])
+      end
+      
+      it "should remove users' keys" do
+        keys = double()
+        users = double()
+        limit = double()
+        key = double()
+        key.should_receive(:destroy).and_return(true)
+        limit.should_receive(:limit).with(1).and_return([key])
+        users.should_receive(:where).with("users.login" => "login").and_return(limit)
+        keys.should_receive(:includes).with(:user).and_return(users)
+        Key.should_receive(:where).with(name: "keyname").and_return(keys)
+        create_executor('.', 'tmp').execute(["user:key:rm", "login", "keyname"])
+      end
+      
+      it "should add admin rights to user" do
+        user = double()
+        user.should_receive(:admin=).with(true)
+        user.should_receive(:save).and_return(true)
+        User.should_receive(:find_by_login).with("login").and_return(user)
+        create_executor('.', 'tmp').execute(["user:admin:add", "login"])
+      end
+      
+      it "should remove admin rights from users" do
+        user = double()
+        user.should_receive(:admin=).with(false)
+        user.should_receive(:save).and_return(true)
+        User.should_receive(:find_by_login).with("login").and_return(user)
+        create_executor('.', 'tmp').execute(["user:admin:rm", "login"])
+      end
+      
+      it "should list repos" do
+        Repository.should_receive(:all).and_return([])
+        create_executor('.', 'tmp').execute(["repo:list"])
+      end
+      
+      it "should create repos" do
+        repo = double()
+        repo.should_receive(:save).and_return(true)
+        Repository.should_receive(:new).with(name: "repo.git", path: "tmp").and_return(repo)
+        create_executor('.', 'tmp').execute(["repo:add", "repo.git"])
+      end
+      
+      it "should create repos and add a user" do
+        repo = double()
+        repo.should_receive(:save).and_return(true)
+        Repository.should_receive(:new).with(name: "repo.git", path: "tmp").and_return(repo)
+        
+        user = double()
+        user.should_receive(:add_access).twice
+        User.should_receive(:find_by_login).with("login").and_return(user)
+        
+        create_executor('.', 'tmp').execute(["repo:add", "repo.git", "login"])
+      end
+      
+      it "should list repos' users" do
+        repo = double()
+        repo.should_receive(:users).and_return([])
+        Repository.should_receive(:find_by_name).with("repo.git").and_return(repo)
+        create_executor('.', 'tmp').execute(["repo:user:list", "repo.git"])
+      end
+      
+      it "should remove repos" do
+        repo = double()
+        repo.should_receive(:destroy).and_return(true)
+        Repository.should_receive(:find_by_name).with("repo.git").and_return(repo)
+        create_executor('.', 'tmp').execute(["repo:rm", "repo.git"]) 
+      end
+      
+      it "should allow user to read a repo" do
+        repo = double()
+        Repository.should_receive(:find_by_name).with("repo.git").and_return(repo)
+        
+        user = double()
+        user.should_receive(:add_access).with(repo, :read).and_return(true)
+        User.should_receive(:find_by_login).with("login").and_return(user)
+        
+        create_executor('.', 'tmp').execute(["repo:read:add", "repo.git", "login"]) 
+      end
+      
+      it "should allow user to write to a repo" do
+        repo = double()
+        Repository.should_receive(:find_by_name).with("repo.git").and_return(repo)
+        
+        user = double()
+        user.should_receive(:add_access).with(repo, :write).and_return(true)
+        User.should_receive(:find_by_login).with("login").and_return(user)
+        
+        create_executor('.', 'tmp').execute(["repo:write:add", "repo.git", "login"])
+      end
+      
+      it "should deny user to read a repo" do
+        repo = double()
+        Repository.should_receive(:find_by_name).with("repo.git").and_return(repo)
+        
+        user = double()
+        user.should_receive(:remove_access).with(repo, :read).and_return(true)
+        User.should_receive(:find_by_login).with("login").and_return(user)
+        
+        create_executor('.', 'tmp').execute(["repo:read:rm", "repo.git", "login"])
+      end
+      
+      it "should deny user to write to a repo"do
+        repo = double()
+        Repository.should_receive(:find_by_name).with("repo.git").and_return(repo)
+        
+        user = double()
+        user.should_receive(:remove_access).with(repo, :write).and_return(true)
+        User.should_receive(:find_by_login).with("login").and_return(user)
+        
+        create_executor('.', 'tmp').execute(["repo:write:rm", "repo.git", "login"])
+      end
+    end
+  end
+end