gerd 0.0.1

data/lib/gerd/invoke.rb

@@ -0,0 +1,18 @@
+module Gerd
+    module Helpers
+
+      class Exec
+
+        def initialize(script)
+          @script = script
+        end
+
+        def exec(model)
+          eval @script
+          invoke_script(model)
+        end
+
+      end
+
+  end
+end

data/lib/gerd/model/model.rb

@@ -0,0 +1,95 @@
+require 'json'
+require 'gerd/exceptions'
+
+module Gerd
+  module Model
+
+    class GithubState
+
+      attr_accessor :organisation, :teams, :members, :repositories, :failures
+
+      def self.from_json(json)
+         begin
+          return Gerd::Model::GithubState.new(JSON.parse(json))
+        rescue => e
+          puts json
+          raise Gerd::Exceptions::ValidationException.new("Couldn't parse JSON")
+        end
+        
+      end
+
+      def initialize(state_content)
+        
+        validators = []
+        validators << Gerd::Model::SchemaValidator.new( Proc.new { | data | data['organisation'] != nil }, "Should have an organisation present")
+        validators << Gerd::Model::SchemaValidator.new( Proc.new { | data | data['teams'].class == Hash }, "Should have a teams element present")
+        validators << Gerd::Model::SchemaValidator.new( Proc.new { | data | data['repositories'].class == Hash }, "Should have a repositories element present")
+        validators << Gerd::Model::SchemaValidator.new( Proc.new { | data | data['members'].class == Hash }, "Should have a members element present")
+        failures = []
+        validators.each do | validator |
+          result = validator.evaluate(state_content)
+          failures << result unless result.valid?
+        end
+
+        @failures = failures
+        if failures.length != 0 
+           failures.each do | failure |
+              puts failure.message
+            end
+            puts state_content
+           raise Gerd::Exceptions::ValidationException.new("Failed to validate #{failures}") 
+        end
+
+        @organisation = state_content['organisation']
+        @teams = state_content['teams']
+        @members = state_content['members']
+        @repositories = state_content['repositories']
+
+      end
+
+      def serialize
+        json = { 'organisation' => @organisation,
+          'teams' => @teams,
+          'members' => @members,
+          'repositories' => @repositories
+        }
+        json
+      end
+
+    end
+
+    class SchemaValidator
+
+        def initialize(expression, message)
+          @expression = expression
+          @message = message
+        end
+
+        def evaluate(content)
+          res = @expression.call(content)
+          Gerd::Model::ValidationResult.new(res, @message)
+        end
+
+    end
+
+    class ValidationResult
+
+      attr_accessor :message
+
+      def initialize(result, message)
+        @result = result
+        @message = message
+      end
+
+      def valid?
+        @result
+      end
+
+      def to_s
+        puts @message
+      end
+
+    end
+
+  end
+end

data/lib/gerd/validators.rb

@@ -0,0 +1,55 @@
+require 'gerd/model/model'
+require 'gerd/inspections/diffs/organisation'
+require 'gerd/inspections/diffs/repositories'
+
+module Gerd
+  module Validation
+
+    class Diff
+
+      def initialize(expression, name)
+        @expression = expression
+        @name = name
+      end
+
+      def validate(expected, actual)
+        puts expected
+        res = @expression.call(expected, actual)
+        res ? "#{@name} passed" : "#{@name} failed"
+      end
+
+    end
+
+    StandardDiffs =[
+          Gerd::Validation::Diff.new( Proc.new { | e, a | e.organisation == a.organisation}, "Organisations"),
+      ]
+
+
+    class Validator
+
+      def initialize(expected_state, actual_state)
+        @expected = expected_state
+        @actual = actual_state
+      end
+
+      def validate
+        validation_result = []
+        validation_result << Gerd::Inspections::Organisation.inspect_organisations(@expected, @actual)
+        validation_result << Gerd::Inspections::Repositories.inspect_repositories(@expected, @actual)
+        validation_result << Gerd::Inspections::Organisation.inspect_teams(@expected, @actual)
+        report = validation_result.flatten.collect { | res | res.message }
+        report
+      end
+
+      def collect_actions
+        actions = []
+        actions << Gerd::Inspections::Organisation.inspect_organisations(@expected, @actual)
+        actions << Gerd::Inspections::Repositories.inspect_repositories(@expected, @actual)
+        actions << Gerd::Inspections::Organisation.inspect_teams(@expected, @actual)
+        actions.flatten.collect { | res | res.actions }
+      end
+    end
+
+ end   
+
+end

data/lib/gerd/version.rb

@@ -0,0 +1,4 @@
+
+module Gerd
+  VERSION = "0.0.1"
+end

data/local.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+
+###########
+##
+##  Source this to set up the ability to use the gem locally without installing during dev
+## 
+##########
+
+export RUBYLIB="${PWD}/lib:$RUBYLIB"
+export PATH="$PATH:${PWD}/bin"

data/spec/model_spec.rb

@@ -0,0 +1,149 @@
+require 'spec_helper'
+require 'gerd/model/model'
+require 'gerd/exceptions'
+
+describe Gerd::Model::GithubState do
+
+  context "validation" do
+
+    it "should validate good json" do
+
+      content = load_fixture('good_state.json')
+    
+      state = Gerd::Model::GithubState.from_json(content)
+      
+    end
+
+    it "Should pull out the organisation" do
+
+        content = load_fixture('good_state.json')
+    
+        state = Gerd::Model::GithubState.from_json(content)
+
+        expect(state.organisation).to eq "Elevenware"
+
+    end
+
+    it "Should have two teams" do
+
+      content = load_fixture('good_state.json')
+    
+      state = Gerd::Model::GithubState.from_json(content)
+
+      expect(state.teams.length).to eq 2
+
+    end
+
+    it "Should have three members" do
+
+      content = load_fixture('good_state.json')
+    
+      state = Gerd::Model::GithubState.from_json(content)
+
+      expect(state.members.length).to eq 3
+
+    end
+
+    it "Should have seven repositories" do
+
+      content = load_fixture('good_state.json')
+    
+      state = Gerd::Model::GithubState.from_json(content)
+
+      expect(state.repositories.length).to eq 7
+
+    end
+
+    it "should not validate malformed json" do
+
+      content = "{"
+
+      expect {Gerd::Model::GithubState.from_json(content) }.to raise_error Gerd::Exceptions::ValidationException
+      
+    end
+
+    it "should not validate if no organisation is present" do
+      content = {
+        "teams" => {},
+        "repositories" => {},
+        "members" => {}
+      }
+      
+
+      expect {Gerd::Model::GithubState.new(content) }.to raise_error Gerd::Exceptions::ValidationException
+      
+
+    end
+
+    it "should not validate if no team element is present" do
+      content = { 
+        "organisation" => "test",
+        "repositories" => {},
+        "members" => {}
+      }
+
+     expect {Gerd::Model::GithubState.new(content) }.to raise_error Gerd::Exceptions::ValidationException
+
+    end
+
+    it "should not validate if the team element is not an object" do
+      content = { 
+        "organisation" => "test",
+        "teams" => "a string",
+        "repositories" => {},
+        "members" => {}
+      }
+
+      expect {Gerd::Model::GithubState.new(content) }.to raise_error Gerd::Exceptions::ValidationException
+
+    end
+
+    it "should not validate if no repositories element is present" do
+      content = { 
+        "organisation" => "test",
+        "teams" => {},
+        "members" => {}
+      }
+
+      expect {Gerd::Model::GithubState.new(content) }.to raise_error Gerd::Exceptions::ValidationException
+
+    end
+
+    it "should not validate if the repositories element is not an object" do
+      content = { 
+        "organisation" => "test",
+        "teams" => {},
+        "repositories" => "dve",
+        "members" => {}
+      }
+
+      expect {Gerd::Model::GithubState.new(content) }.to raise_error Gerd::Exceptions::ValidationException
+
+    end
+
+    it "should not validate if no members element is present" do
+      content = { 
+        "organisation" => "test",
+        "teams" => {},
+        "repositories" => {}
+      }
+
+      expect {Gerd::Model::GithubState.new(content) }.to raise_error Gerd::Exceptions::ValidationException
+
+    end
+
+    it "should not validate if the members element is not an object" do
+      content = { 
+        "organisation" => "test",
+        "teams" => {},
+        "repositories" => {},
+        "members" => ""
+      }
+
+      expect {Gerd::Model::GithubState.new(content) }.to raise_error Gerd::Exceptions::ValidationException 
+
+    end
+
+  end
+
+end

data/spec/organisation_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+require 'gerd/model/model'
+require 'gerd/inspections/diffs/organisation'
+
+
+describe "organisation diff" do
+
+  context "states match" do
+
+    expected = Gerd::Model::GithubState.new( 
+    { 
+      "organisation" => "Test organisation",
+      "teams" => {},
+      "members" => {},
+      "repositories" => {}
+    })
+
+    actual = Gerd::Model::GithubState.new( 
+    { 
+      "organisation" => "Test organisation",
+      "teams" => {},
+      "members" => {},
+      "repositories" => {}
+    })
+
+    diff = Gerd::Inspections::Organisation::inspect_organisations(expected, actual)
+
+    it "should spot same organisations" do
+      
+      expect(diff.passed).to be true
+
+    end
+
+    it "should give us no actions" do
+
+      expect(diff.actions.length).to be 0
+
+    end
+
+  end
+
+  context "states do not match" do
+
+    expected = Gerd::Model::GithubState.new( 
+    { 
+      "organisation" => "Test organisation",
+      "teams" => {},
+      "members" => {},
+      "repositories" => {}
+    })
+
+    actual = Gerd::Model::GithubState.new( 
+    { 
+      "organisation" => "Other organisation",
+      "teams" => {},
+      "members" => {},
+      "repositories" => {}
+    })
+
+    diff = Gerd::Inspections::Organisation::inspect_organisations(expected, actual)
+     
+    it "should spot different organisations" do
+  
+      expect(diff.passed).to be false
+
+    end
+
+    it "should give us a name change action" do
+
+      expect(diff.actions.length).to be 1
+
+    end
+
+  end
+
+end

data/spec/repositories_spec.rb

@@ -0,0 +1,223 @@
+require 'spec_helper'
+require 'gerd/model/model'
+require 'gerd/inspections/diffs/repositories'
+
+describe 'repositories inspection' do
+
+  context 'repositories match' do
+
+    expected = Gerd::Model::GithubState.new( 
+    { 
+      "organisation" => "Test organisation",
+      "teams" => {},
+      "members" => {},
+      "repositories" => {
+        "foo" => {
+          "private" => false
+        },
+        "bar" => {
+          "private" => false
+        }
+      }
+    })
+
+    actual = Gerd::Model::GithubState.new( 
+    { 
+      "organisation" => "Test organisation",
+      "teams" => {},
+      "members" => {},
+      "repositories" => {
+        "foo" => {
+          "private" => false
+        },
+        "bar" => {
+          "private" => false
+        }
+      }
+    })
+
+    diffs = Gerd::Inspections::Repositories::inspect_repositories(expected, actual)
+
+    it "should give me 0 diffs" do
+
+      expect(diffs.length).to be 0
+
+    end 
+
+  end
+
+  context 'missing repository' do
+
+    expected = Gerd::Model::GithubState.new( 
+    { 
+      "organisation" => "Test organisation",
+      "teams" => {},
+      "members" => {},
+      "repositories" => {
+        "foo" => {
+          "private" => false
+        },
+        "bar" => {
+          "private" => false
+        }
+      }
+    })
+
+    actual = Gerd::Model::GithubState.new( 
+    { 
+      "organisation" => "Test organisation",
+      "teams" => {},
+      "members" => {},
+      "repositories" => {
+        "foo" => {
+          "private" => false
+        }
+      }
+    })
+
+    diffs = Gerd::Inspections::Repositories::inspect_repositories(expected, actual)
+
+    it "should give me 1 diff" do
+
+      expect(diffs.length).to be 1
+
+      expect(diffs[0].message).to eq "I expected to see repository bar but did not"
+
+      expect(diffs[0].actions.length).to be 1
+
+      expect(diffs[0].actions[0].class).to be Gerd::Inspections::Actions::CreateRepo
+
+    end 
+
+  end
+
+  context 'extra repository' do
+
+    expected = Gerd::Model::GithubState.new( 
+    { 
+      "organisation" => "Test organisation",
+      "teams" => {},
+      "members" => {},
+      "repositories" => {
+        "foo" => {
+          "private" => false
+        }
+      }
+    })
+
+    actual = Gerd::Model::GithubState.new( 
+    { 
+      "organisation" => "Test organisation",
+      "teams" => {},
+      "members" => {},
+      "repositories" => {
+        "foo" => {
+          "private" => false
+        },
+        "bar" => {
+          "private" => false
+        }
+      }
+    })
+
+    diffs = Gerd::Inspections::Repositories::inspect_repositories(expected, actual)
+
+    it "should give me 1 diff" do
+
+      expect(diffs.length).to be 1
+
+      expect(diffs[0].message).to eq "I did not expect to see repository bar but saw it anyway"
+
+      expect(diffs[0].actions.length).to be 1
+
+      expect(diffs[0].actions[0].class).to be Gerd::Inspections::Actions::DeleteRepo
+
+    end 
+
+  end
+
+  context 'repository should be private' do
+
+    expected = Gerd::Model::GithubState.new( 
+    { 
+      "organisation" => "Test organisation",
+      "teams" => {},
+      "members" => {},
+      "repositories" => {
+        "foo" => {
+          "private" => true
+        }
+      }
+    })
+
+    actual = Gerd::Model::GithubState.new( 
+    { 
+      "organisation" => "Test organisation",
+      "teams" => {},
+      "members" => {},
+      "repositories" => {
+        "foo" => {
+          "private" => false
+        }
+      }
+    })
+
+    diffs = Gerd::Inspections::Repositories::inspect_repositories(expected, actual)
+
+    it "should give me 1 diff" do
+
+      expect(diffs.length).to be 1
+
+      expect(diffs[0].message).to eq "I expected repo foo to be private, but it is not"
+
+      expect(diffs[0].actions.length).to be 1
+
+      expect(diffs[0].actions[0].class).to be Gerd::Inspections::Actions::ChangeRepoPrivacy
+
+    end 
+
+  end
+
+  context 'repository should be public' do
+
+    expected = Gerd::Model::GithubState.new( 
+    { 
+      "organisation" => "Test organisation",
+      "teams" => {},
+      "members" => {},
+      "repositories" => {
+        "foo" => {
+          "private" => false
+        }
+      }
+    })
+
+    actual = Gerd::Model::GithubState.new( 
+    { 
+      "organisation" => "Test organisation",
+      "teams" => {},
+      "members" => {},
+      "repositories" => {
+        "foo" => {
+          "private" => true
+        }
+      }
+    })
+
+    diffs = Gerd::Inspections::Repositories::inspect_repositories(expected, actual)
+
+    it "should give me 1 diff" do
+
+      expect(diffs.length).to be 1
+
+      expect(diffs[0].message).to eq "I did not expect repo foo to be private, but it is"
+
+      expect(diffs[0].actions.length).to be 1
+
+      expect(diffs[0].actions[0].class).to be Gerd::Inspections::Actions::ChangeRepoPrivacy
+
+    end 
+
+  end
+  
+end