git_duplicator 0.0.1 → 1.0.0

data/lib/git_duplicator/services/github.rb

@@ -1,26 +1,25 @@
 require 'http'
-require_relative '../helpers/authorization_header'
-
 module GitDuplicator
   module Services
     class GithubRepository < ServiceRepository
       BASE_URI = 'https://api.github.com'
 
-      attr_accessor :credentials, :options
+      attr_accessor :credentials, :remote_options, :working_directory
 
       # Initializer
-      # @param [String] name name of the repository
-      # @param [String] owner owner of the repository
-      # @param [Hash] credentials
-      # @option credentials [Symbol] :oauth2_token used in oAuth2 authentication
-      # @option credentials [Symbol] :username used in basic authentication
-      # @option credentials [Symbol] :password used in basic authentication
-      # @param [Hash] options options for creation
-      # @see https://developer.github.com/v3/repos/#create
-      def initialize(name, owner, credentials = {}, options = {})
-        super(name, owner)
-        self.credentials = credentials
-        self.options = options
+      # @param [Hash] options
+      #   * :credentials (Hash) credentials for remote service
+      #     * :oauth2_token (Symbol) used in oAuth2 authentication
+      #     * :username (Symbol) used in basic authentication
+      #     * :password (Symbol) used in basic authentication
+      #   * :remote_options (Hash) creation options for remote service
+      #    @see @see https://developer.github.com/v3/repos/#create
+      #   * :working_directory (String) assing a working directory
+      def initialize(name, owner, options = {})
+        self.credentials = options.fetch(:credentials) { {} }
+        self.remote_options = options.fetch(:remote_options) { {} }
+        self.working_directory = options.fetch(:working_directory) { nil }
+        super(name, owner, working_directory)
       end
 
       # URL of the repositroy
@@ -33,7 +32,7 @@ module GitDuplicator
       def create
         request_url = BASE_URI + '/user/repos'
         response = HTTP.with(headers(:post, request_url))
-        .post(request_url, json: options.merge(name: name))
+        .post(request_url, json: remote_options.merge(name: name))
         code, body = response.code.to_i, response.body
         fail(RepositoryCreationError, body) unless 201 == code
       end

data/lib/git_duplicator/version.rb

@@ -1,9 +1,9 @@
 module GitDuplicator
   # Gem's version
   class Version
-    MAJOR = 0
+    MAJOR = 1
     MINOR = 0
-    PATCH = 1
+    PATCH = 0
 
     class << self
       # @return [String]

data/spec/git_duplicator/duplicator/duplicator_spec.rb

@@ -0,0 +1,112 @@
+require_relative '../../helper'
+
+module GitDuplicator
+
+  describe Duplicator do
+    let(:path) { '/somepath' }
+    let(:from) do
+      double(name: 'somename', bare_clone: nil, mirror: nil, url: 'somewhere1')
+    end
+    let(:to) { double(delete: nil, create: nil, url: 'somewhere2') }
+    let(:duplicator) { described_class.new(from, to, options) }
+
+    describe '#perform_mirror' do
+      let(:options) { {} }
+      it 'raises an exception in case of not defined' do
+        expect { duplicator.perform_mirror }
+        .to raise_error(NotImplementedError)
+      end
+    end
+
+    describe '#perform_clone_source' do
+      let(:options) { {} }
+      it 'raises an exception in case of not defined' do
+        expect { duplicator.perform_clone_source }
+        .to raise_error(NotImplementedError)
+      end
+    end
+
+    describe '#perform_clean_up' do
+      let(:options) { {} }
+      it 'raises an exception in case of not defined' do
+        expect { duplicator.perform_clean_up }
+        .to raise_error(NotImplementedError)
+      end
+    end
+
+    describe '#perform' do
+      before do
+        allow(duplicator).to receive(:perform_clone_source)
+        allow(duplicator).to receive(:perform_mirror)
+        allow(duplicator).to receive(:perform_clean_up)
+      end
+      context 'force_create_destination is set' do
+        let(:options) { { clone_path: path, force_create_destination: true } }
+
+        it 'deletes existing destination repo' do
+          expect(to).to receive(:delete)
+          duplicator.perform
+        end
+
+        it 'creates the destination repo' do
+          expect(to).to receive(:create)
+          duplicator.perform
+        end
+
+        it 'clones the source repo' do
+          expect(duplicator).to receive(:clone_source)
+          duplicator.perform
+        end
+
+        it 'mirrors to destination' do
+          expect(duplicator).to receive(:mirror)
+          duplicator.perform
+        end
+
+        it 'cleans up' do
+          expect(duplicator).to receive(:clean_up)
+          duplicator.perform
+        end
+
+        it 'logs 5 times' do
+          expect(duplicator.logger).to receive(:info).exactly(5).times
+          duplicator.perform
+        end
+      end
+
+      context 'force_create_destination is false' do
+        let(:options) { { clone_path: path } }
+
+        it 'deletes existing destination repo' do
+          expect(to).not_to receive(:delete)
+          duplicator.perform
+        end
+
+        it 'creates the destination repo' do
+          expect(to).not_to receive(:create)
+          duplicator.perform
+        end
+
+        it 'clones the source repo' do
+          expect(duplicator).to receive(:clone_source)
+          duplicator.perform
+        end
+
+        it 'mirrors to destination' do
+          expect(duplicator).to receive(:mirror)
+          duplicator.perform
+        end
+
+        it 'cleans up' do
+          expect(duplicator).to receive(:clean_up)
+          duplicator.perform
+        end
+
+        it 'logs 3 times' do
+          expect(duplicator.logger).to receive(:info).exactly(3).times
+          duplicator.perform
+        end
+      end
+    end
+  end
+end

data/spec/git_duplicator/duplicator/mirror_duplicator_spec.rb

@@ -0,0 +1,35 @@
+require_relative '../../helper'
+
+module GitDuplicator
+  describe MirrorDuplicator do
+    let(:path) { '/somepath' }
+    let(:from) do
+      double(name: 'somename', bare_clone: nil, mirror: nil, url: 'somewhere1')
+    end
+    let(:options) { { clone_path: path, force_create_destination: true } }
+    let(:to) { double(delete: nil, create: nil, url: 'somewhere2') }
+    let(:duplicator) { described_class.new(from, to, options) }
+
+    describe '#clone_source' do
+      it 'bare clones the source repo' do
+        expect(from).to receive(:bare_clone).with(path)
+        duplicator.perform
+      end
+    end
+
+    describe '#mirror' do
+      it 'mirrors from bare clone to destination' do
+        expect(from).to receive(:mirror).with(to.url)
+        duplicator.perform
+      end
+    end
+
+    describe '#clean_up' do
+      it 'mirrors from bare clone to destination' do
+        expect(FileUtils).to receive(:rm_rf)
+        .with("#{duplicator.clone_path}/#{from.name}")
+        duplicator.perform
+      end
+    end
+  end
+end

data/spec/git_duplicator/duplicator/update_duplicator_spec.rb

@@ -0,0 +1,39 @@
+require_relative '../../helper'
+
+module GitDuplicator
+  describe UpdateDuplicator do
+    let(:path) { '/somepath' }
+    let(:from) do
+      double(name: 'somename', mirror_clone: nil, set_mirrored_remote: nil,
+             update_mirrored: nil, url: 'somewhere1')
+    end
+    let(:options) { { clone_path: path, force_create_destination: true } }
+    let(:to) { double(delete: nil, create: nil, url: 'somewhere2') }
+    let(:duplicator) { described_class.new(from, to, options) }
+
+    describe '#clone_source' do
+      it 'bare clones the source repo' do
+        expect(from).to receive(:mirror_clone).with(path)
+        duplicator.perform
+      end
+    end
+
+    describe '#mirror' do
+      it 'sets the remote for push' do
+        expect(from).to receive(:set_mirrored_remote).with(to.url)
+        duplicator.perform
+      end
+
+      it 'mirrors from mirror clone to destination' do
+        expect(from).to receive(:update_mirrored)
+        duplicator.perform
+      end
+    end
+
+    describe '#clean_up' do
+      it 'mirrors from bare clone to destination' do
+        expect(duplicator.perform).to be_nil
+      end
+    end
+  end
+end

data/spec/git_duplicator/git_duplicator_acceptance_spec.rb

@@ -0,0 +1,188 @@
+require_relative '../helper'
+
+def random_name
+  rand(36**5).to_s(36)
+end
+
+describe GitDuplicator do
+  before(:each) { WebMock.allow_net_connect! }
+  let(:clone_path) { '/tmp' }
+  let(:credentials) do
+    { consumer_key: ENV['BITBUCKET_CONSUMER_KEY'],
+      consumer_secret: ENV['BITBUCKET_CONSUMER_SECRET'],
+      token: ENV['BITBUCKET_TOKEN'],
+      token_secret: ENV['BITBUCKET_TOKEN_SECRET'] }
+  end
+  let(:options) { { credentials: credentials } }
+
+  describe '#perform' do
+    it 'mirrors from service to service without ' \
+    'force_create_destination option' do
+      skip
+      # Setup
+      from = GitDuplicator::Services::GithubRepository
+      .new('naught', 'avdi')
+      to = GitDuplicator::Services::BitbucketRepository
+      .new(ENV['TESTING_REPO'], ENV['BITBUCKET_USER'], options)
+      to.create
+      GitDuplicator.perform(from, to, clone_path: clone_path)
+      source_name = random_name
+      mirrored_name = random_name
+
+      # Exercise
+      source = Git.clone(from.url, source_name, path: clone_path)
+      mirrored = Git.clone(to.url, mirrored_name, path: clone_path)
+
+      # Verify
+      expect(mirrored.object('HEAD^').to_s).to eq(source.object('HEAD^').to_s)
+
+      # Teardown
+      FileUtils.rm_rf("#{clone_path}/#{source_name}")
+      FileUtils.rm_rf("#{clone_path}/#{mirrored_name}")
+      to.delete
+    end
+
+    it 'mirrors from service to service with ' \
+    'force_create_destination option' do
+      skip
+      # Setup
+      from = GitDuplicator::Services::GithubRepository
+      .new('naught', 'avdi')
+      to = GitDuplicator::Services::BitbucketRepository
+      .new(ENV['TESTING_REPO'], ENV['BITBUCKET_USER'], options)
+      GitDuplicator.perform(from, to,
+                            clone_path: clone_path,
+                            force_create_destination: true)
+      source_name = random_name
+      mirrored_name = random_name
+
+      # Exercise
+      source = Git.clone(from.url, source_name, path: clone_path)
+      mirrored = Git.clone(to.url, mirrored_name, path: clone_path)
+
+      # Verify
+      expect(mirrored.object('HEAD^').to_s).to eq(source.object('HEAD^').to_s)
+
+      # Teardown
+      FileUtils.rm_rf("#{clone_path}/#{source_name}")
+      FileUtils.rm_rf("#{clone_path}/#{mirrored_name}")
+      to.delete
+    end
+
+    it 'mirrors from basic to service with ' \
+    'force_create_destination option' do
+      skip
+      # Setup
+      from = GitDuplicator::Repository
+      .new('naught', 'https://github.com/avdi/naught.git')
+      to = GitDuplicator::Services::BitbucketRepository
+      .new(ENV['TESTING_REPO'], ENV['BITBUCKET_USER'], options)
+      GitDuplicator.perform(from, to,
+                            clone_path: clone_path,
+                            force_create_destination: true)
+      source_name = random_name
+      mirrored_name = random_name
+
+      # Exercise
+      source = Git.clone(from.url, source_name, path: clone_path)
+      mirrored = Git.clone(to.url, mirrored_name, path: clone_path)
+
+      # Verify
+      expect(mirrored.object('HEAD^').to_s).to eq(source.object('HEAD^').to_s)
+
+      # Teardown
+      FileUtils.rm_rf("#{clone_path}/#{source_name}")
+      FileUtils.rm_rf("#{clone_path}/#{mirrored_name}")
+      to.delete
+    end
+  end
+
+  describe '#perform_for_updates' do
+    it 'mirrors from service to service without ' \
+    'force_create_destination option' do
+      skip
+      # Setup
+      from = GitDuplicator::Services::GithubRepository
+      .new('naught', 'avdi')
+      to = GitDuplicator::Services::BitbucketRepository
+      .new(ENV['TESTING_REPO'], ENV['BITBUCKET_USER'], options)
+      to.create
+      GitDuplicator.perform_for_update(from, to, clone_path: clone_path)
+      source_name = from.name
+      mirrored_name = random_name
+
+      # Exercise
+      source = Git.bare("#{clone_path}/#{source_name}")
+      mirrored = Git.clone(to.url, mirrored_name, path: clone_path)
+
+      # Verify
+      expect(mirrored.object('HEAD^').to_s).to eq(source.object('HEAD^').to_s)
+
+      # Teardown
+      FileUtils.rm_rf("#{clone_path}/#{source_name}")
+      FileUtils.rm_rf("#{clone_path}/#{mirrored_name}")
+      to.delete
+    end
+
+    it 'mirrors from service to service with ' \
+    'force_create_destination option' do
+      skip
+      # Setup
+      from = GitDuplicator::Services::GithubRepository
+      .new('naught', 'avdi')
+      to = GitDuplicator::Services::BitbucketRepository
+      .new(ENV['TESTING_REPO'], ENV['BITBUCKET_USER'], options)
+      GitDuplicator.perform_for_update(from, to,
+                                       clone_path: clone_path,
+                                       force_create_destination: true)
+      source_name = from.name
+      mirrored_name = random_name
+
+      # Exercise
+      source = Git.bare("#{clone_path}/#{source_name}")
+      mirrored = Git.clone(to.url, mirrored_name, path: clone_path)
+
+      # Verify
+      expect(mirrored.object('HEAD^').to_s).to eq(source.object('HEAD^').to_s)
+
+      # Teardown
+      FileUtils.rm_rf("#{clone_path}/#{source_name}")
+      FileUtils.rm_rf("#{clone_path}/#{mirrored_name}")
+      to.delete
+    end
+
+    it 'mirrors from basic to service with ' \
+    'force_create_destination option' do
+      skip
+      # Setup
+      from = GitDuplicator::Repository
+      .new('naught', 'https://github.com/avdi/naught.git')
+      to = GitDuplicator::Services::BitbucketRepository
+      .new(ENV['TESTING_REPO'], ENV['BITBUCKET_USER'], options)
+      GitDuplicator.perform_for_update(from, to,
+                                       clone_path: clone_path,
+                                       force_create_destination: true)
+      source_name = from.name
+      mirrored_name = random_name
+
+      # Exercise
+      source = Git.bare("#{clone_path}/#{source_name}")
+      mirrored = Git.clone(to.url, mirrored_name, path: clone_path)
+
+      # Verify
+      expect(mirrored.object('HEAD^').to_s).to eq(source.object('HEAD^').to_s)
+
+      local_repo = GitDuplicator::Repository.new(
+        'naught',
+        'https://github.com/avdi/naught.git',
+        "#{clone_path}/#{source_name}"
+      )
+      local_repo.update_mirrored
+
+      #Teardown
+      FileUtils.rm_rf("#{clone_path}/#{source_name}")
+      FileUtils.rm_rf("#{clone_path}/#{mirrored_name}")
+      to.delete
+    end
+  end
+end

data/spec/git_duplicator/git_duplicator_spec.rb

@@ -1,102 +1,32 @@
 require_relative '../helper'
 
-def random_name
-  rand(36**5).to_s(36)
-end
-
 describe GitDuplicator do
-  before(:each) { WebMock.allow_net_connect! }
   let(:clone_path) { '/tmp' }
-
+  let(:credentials) do
+    { consumer_key: ENV['BITBUCKET_CONSUMER_KEY'],
+      consumer_secret: ENV['BITBUCKET_CONSUMER_SECRET'],
+      token: ENV['BITBUCKET_TOKEN'],
+      token_secret: ENV['BITBUCKET_TOKEN_SECRET'] }
+  end
+  let(:options) { { clone_path: clone_path } }
+  let(:from) { GitDuplicator::Repository }
+  let(:to) { GitDuplicator::Repository }
+  let(:result) { double(perform: nil) }
   describe '#perform' do
-
-    let(:credentials) do
-      { consumer_key: ENV['BITBUCKET_CONSUMER_KEY'],
-        consumer_secret: ENV['BITBUCKET_CONSUMER_SECRET'],
-        token: ENV['BITBUCKET_TOKEN'],
-        token_secret: ENV['BITBUCKET_TOKEN_SECRET'] }
+    it 'delegates to MirrorDuplicator' do
+      expect(GitDuplicator::MirrorDuplicator)
+      .to receive(:new).with(from, to, options).and_return(result)
+      expect(result).to receive(:perform)
+      GitDuplicator.perform(from, to, options)
     end
+  end
 
-    it 'mirrors from service to service without ' \
-    'force_create_destination option' do
-      skip
-      # Setup
-      from = GitDuplicator::Services::GithubRepository
-      .new('naught', 'avdi')
-      to = GitDuplicator::Services::BitbucketRepository
-      .new(ENV['TESTING_REPO'], ENV['BITBUCKET_USER'], credentials)
-      to.create
-      GitDuplicator.perform(from, to, clone_path: clone_path)
-      mirrored_name = random_name
-      result_name = random_name
-
-      # Exercise
-      mirrored = Git.clone(from.url, mirrored_name, path: clone_path)
-      result = Git.clone(from.url, result_name, path: clone_path)
-
-      # Verify
-      expect(result.object('HEAD^').to_s).to eq(mirrored.object('HEAD^').to_s)
-
-      # Teardown
-      FileUtils.rm_rf("#{clone_path}/#{mirrored_name}")
-      FileUtils.rm_rf("#{clone_path}/#{result_name}")
-      to.delete
-    end
-
-    it 'mirrors from service to service with ' \
-    'force_create_destination option' do
-      skip
-      # Setup
-      from = GitDuplicator::Services::GithubRepository
-      .new('naught', 'avdi')
-      to = GitDuplicator::Services::BitbucketRepository
-      .new(ENV['TESTING_REPO'], ENV['BITBUCKET_USER'], credentials)
-      GitDuplicator.perform(from, to,
-                            clone_path: clone_path,
-                            force_create_destination: true)
-      mirrored_name = random_name
-      result_name = random_name
-
-      # Exercise
-      mirrored = Git.clone(from.url, mirrored_name, path: clone_path)
-      result = Git.clone(from.url, result_name, path: clone_path)
-
-      # Verify
-      expect(result.object('HEAD^').to_s).to eq(mirrored.object('HEAD^').to_s)
-
-      # Teardown
-      FileUtils.rm_rf("#{clone_path}/#{mirrored_name}")
-      FileUtils.rm_rf("#{clone_path}/#{result_name}")
-      to.delete
-    end
-
-    it 'mirrors from basic to service with ' \
-    'force_create_destination option' do
-      skip
-      # Setup
-      from = GitDuplicator::Repository
-      .new('naught', 'https://github.com/avdi/naught.git')
-      to = GitDuplicator::Services::BitbucketRepository
-      .new(ENV['TESTING_REPO'], ENV['BITBUCKET_USER'], credentials)
-      GitDuplicator.perform(from, to,
-                            clone_path: clone_path,
-                            force_create_destination: true)
-      mirrored_name = random_name
-      result_name = random_name
-
-      # Exercise
-      mirrored = Git.clone(from.url, mirrored_name, path: clone_path)
-      result = Git.clone(from.url, result_name, path: clone_path)
-
-      # Verify
-      expect(result.object('HEAD^').to_s).to eq(mirrored.object('HEAD^').to_s)
-
-      # Teardown
-      FileUtils.rm_rf("#{clone_path}/#{mirrored_name}")
-      FileUtils.rm_rf("#{clone_path}/#{result_name}")
-      to.delete
+  describe '#perform_for_update' do
+    it 'delegates to UpdateDuplicator' do
+      expect(GitDuplicator::UpdateDuplicator)
+      .to receive(:new).with(from, to, options).and_return(result)
+      expect(result).to receive(:perform)
+      GitDuplicator.perform_for_update(from, to, options)
     end
-
   end
-
 end