chekku 0.0.4 → 0.0.5

data/README.md

@@ -3,7 +3,7 @@ The gem that checks your software dependencies
 
 ## WARNING
 
-**This gem is in alpha mode! Please use it carefully.**
+**This gem is in early version! Please use it carefully.**
 
 ## Installation
 
@@ -28,14 +28,15 @@ Or install it yourself as:
 
 ## Chekkufile
 
-This is the file that contains the dependencies we need to check
+This is the file that contains the dependencies we need to checks.
 
 Chekkufile :
 
 ```ruby
- check 'mysql', '>= 5.0', env: :production
- check 'redis'
- check 'mongod', '~> 1.0', env: :development, must_run: true
+check 'mysql', must_run: true
+check 'redis'
+check 'postgres', "~> 9.2", must_run: true
+check 'imagemagick', "<= 4"
 ```
 
 ## def.yml
@@ -53,12 +54,11 @@ imagemagick:
   executable: 'convert'
 ```
 
-** I'm currently working on a webapp to define online all the values for this file. So it will be community based. **
 
 ## Future
 
-I'll try to have a version that works for checking the version of the dependecy in the near future.
-And will add tests to check if the service is running or not.
+**I'm currently working on a webapp to define online all the values for this file. So it will be community based.**
+
 
 ## Contributing
 

data/lib/chekku/checker.rb

@@ -1,6 +1,5 @@
 require 'pathname'
-require_relative 'dsl'
-require_relative 'definitions_service'
+require_relative 'definitions'
 
 class Chekku::Checker < Thor
   include Thor::Actions
@@ -20,7 +19,7 @@ class Chekku::Checker < Thor
   private
 
   def check_dependencies
-    Chekku::Dsl.evaluate(@chekkufile)
+    Chekku::Definitions.evaluate(@chekkufile)
   end
 
   def verify_chekku_file_existence

data/lib/chekku/definition.rb

@@ -0,0 +1,85 @@
+#encoding: utf-8
+class Chekku::Definition
+
+  attr_accessor :name, :executable, :version_checker, :errors
+
+  def self.load(definitions_hash = {})
+    [].tap do |definitions|
+      definitions_hash.each_pair do |name, hash_definition|
+        definitions << self.new(hash_definition.merge(name: name))
+      end
+    end
+  end
+
+  def initialize(attributes = {})
+    attributes.each do |name, value|
+      send("#{name}=", value)
+    end
+    @errors = {}
+  end
+
+  def chekku(version = nil, args = {})
+    raise(DefinitionValidationError, "not installed") unless exists?
+    validates version, args
+    "[\033[32m✓\033[0m] #{name}"
+  end
+
+  def exists?
+    verify_executable! && found?
+  end
+
+  def verify_executable!
+    raise(AppNameNotStringError, 'You need to use strings for app names') unless executable.is_a?(String)
+    raise(AppNameNotSaneError, "Sorry the app name '#{name}' is not sane") unless sane_executable?
+    true
+  end
+
+  def found?
+    system "which #{executable} > /dev/null 2>&1"
+  end
+
+  def sane_executable?
+    executable == sanitized_executable
+  end
+
+  def sanitized_executable
+    executable.gsub /&|"|'|;|\s/, ""
+  end
+
+  def validates(version = nil, args = {})
+    raise(DefinitionValidationError, "wrong version: wanted #{version}, got #{installed_version}") unless ( !version || check_version(version))
+    raise(DefinitionValidationError, "installed but not running (must_run: true)") unless (!args[:must_run] || is_running?)
+    true
+  end
+
+  def is_running?
+    ps_result = `ps aux | grep #{executable}`
+    ps_result_array = ps_result.split("\n")
+    ps_result_array.any? do |ps_line|
+      ps_line.include?(executable) && (executable == 'grep' || !ps_line.include?('grep'))
+    end
+  end
+
+  def check_version(version)
+    operator, version = version.split(' ')
+    if version.nil?
+      version = operator
+      operator = '=='
+    end
+    if operator == '~>'
+      installed_version >= Gem::Version.new(version) && installed_version <= Gem::Version.new(version).bump
+    else
+      installed_version.send(operator, Gem::Version.new(version))
+    end
+  end
+
+  def installed_version
+    version_matches = `#{executable} --version`.scan(/(\d+[\.\d+]*)/).flatten
+    max_dot_number_version = ''
+    version_matches.each do |version|
+      max_dot_number_version = version if version.count('.') > max_dot_number_version.count('.')
+    end
+    Gem::Version.new(max_dot_number_version)
+  end
+
+end

data/lib/chekku/definitions.rb

@@ -0,0 +1,46 @@
+#encoding: utf-8
+require_relative 'definition'
+require_relative 'definitions_service'
+
+class Chekku::Definitions
+
+  attr_accessor :definitions_service, :dependency_checker
+
+  def self.evaluate(file)
+    new.eval_chekkufile(file)
+  end
+
+  def initialize
+    @definitions_service = Chekku::DefinitionsService.new
+    @definitions_service.load_definitions_for @chekkufile
+  end
+
+  def eval_chekkufile(file)
+    instance_eval(read_file(file))
+  rescue NoMethodError => e
+    puts "\033[31mERROR: Please verify the syntax of your Chekkufile"
+  end
+
+  def check(name, version = nil, args = {})
+    unless version.is_a?(String)
+      args = version || {}
+      version = nil
+    end
+    definition = get_definition! name
+    puts definition.chekku(version, args)
+  rescue DefinitionsError => e
+    puts "[\033[31m✗\033[0m] #{name}: #{e.message}\n"
+  rescue ChekkuError => e
+    puts "\033[31mERROR: #{e.message}\033[0m\n"
+  end
+
+  def get_definition!(name)
+    @definitions_service.definition_for(name) ||
+      raise(DefinitionNotFoundError, "#{name} definition not found. Check ~/.chekku/def.yml")
+  end
+
+  def read_file(file)
+    File.open(file, "r") { |f| f.read }
+  end
+
+end

data/lib/chekku/definitions_service.rb

@@ -2,14 +2,13 @@ require_relative 'fetcher'
 
 class Chekku::DefinitionsService
 
-  attr_accessor :definitions, :chekkufile
+  attr_accessor :definitions
 
   def load_definitions_for(file)
-    @chekkufile = file
     @definitions = Chekku::Fetcher.fetch_for_chekkufile file
   end
 
   def definition_for(dependency)
-    @definitions[dependency] if @definitions
+    @definitions.select{ |definition| definition.name == dependency }.first if @definitions
   end
 end

data/lib/chekku/errors.rb

@@ -1,4 +1,6 @@
 class DefinitionsError < StandardError; end
-class AppNameNotSaneError < DefinitionsError; end
-class AppNameNotStringError < DefinitionsError; end
-class DefinitionNotFoundError < DefinitionsError; end
+class ChekkuError < StandardError; end
+class AppNameNotSaneError < ChekkuError; end
+class AppNameNotStringError < ChekkuError; end
+class DefinitionNotFoundError < ChekkuError; end
+class DefinitionValidationError < DefinitionsError; end

data/lib/chekku/fetcher.rb

@@ -1,5 +1,6 @@
 #encoding: utf-8
 require 'yaml'
+require_relative 'definition'
 
 class Chekku::Fetcher
 
@@ -15,6 +16,6 @@ class Chekku::Fetcher
   end
 
   def dependencies_from_file
-    @dependencies = YAML.load_file("#{CHEKKU_PATH}/def.yml")
+    @dependencies = Chekku::Definition.load(YAML.load_file("#{CHEKKU_PATH}/def.yml") || {})
   end
 end

data/lib/chekku/version.rb

@@ -1,3 +1,3 @@
 module Chekku
-  VERSION = '0.0.4'
+  VERSION = '0.0.5'
 end

data/spec/lib/definition_spec.rb

@@ -0,0 +1,148 @@
+#encoding: utf-8
+require 'chekku/definition'
+require 'chekku/errors'
+
+describe Chekku::Definition do
+  let(:definition) { Chekku::Definition.new(name: 'mysql', executable: 'mysqld') }
+  describe ".sanitized_executable" do
+    it "should not change a sane command" do
+      definition.sanitized_executable.should == "mysqld"
+    end
+
+    context "not sane commands" do
+      "&\"';\s".each_char do |char|
+        it "should remove #{char}" do
+          definition.executable = "my#{char}sql"
+          definition.sanitized_executable.should == "mysql"
+        end
+      end
+    end
+  end
+  describe '.sane_executable?' do
+    it "should be true with sane command" do
+      definition.sane_executable?.should be_true
+    end
+
+    it "should be false with not sane command" do
+      definition.executable = "my& sql"
+      definition.sane_executable?.should be_false
+    end
+  end
+  describe '.verify_executable!' do
+    it 'should be ok with a sane string' do
+      definition.verify_executable!.should be_true
+    end
+
+    it 'should raise an error with symbol' do
+      definition.executable = :mysql
+      expect { definition.verify_executable! }.to raise_error(AppNameNotStringError)
+    end
+
+    it 'should raise an error with not sane command' do
+      definition.executable = 'my&sql'
+      expect { definition.verify_executable! }.to raise_error(AppNameNotSaneError)
+    end
+  end
+
+  describe '.found?' do
+    it 'should be true for existing executable' do
+      definition.stub(:system).with('which mysqld > /dev/null 2>&1').and_return(true)
+      definition.found?.should be_true
+    end
+
+    it 'should be false for non existing executable' do
+      definition.stub(:system).with('which mysqld > /dev/null 2>&1').and_return(false)
+      definition.found?.should be_false
+    end
+  end
+
+  describe '.exists?' do
+    it 'should be true if executable is valid and found' do
+      definition.stub(:verify_executable!).and_return(true)
+      definition.stub(:found?).and_return(true)
+      definition.exists?.should be_true
+    end
+
+    it 'should be false if executable is invalid' do
+      definition.stub(:verify_executable!).and_return(false)
+      definition.stub(:found?).and_return(true)
+      definition.exists?.should be_false
+    end
+
+    it 'should be false if executable is not found' do
+      definition.stub(:verify_executable!).and_return(true)
+      definition.stub(:found?).and_return(false)
+      definition.exists?.should be_false
+    end
+  end
+
+  describe '.chekku' do
+    it 'should says ✓ if soft exists' do
+      definition.stub(:exists?).and_return(true)
+      definition.chekku.should == "[\033[32m✓\033[0m] mysql"
+    end
+    it 'should says x if soft does not exist' do
+      definition.stub(:exists?).and_return(false)
+      expect { definition.chekku }.to raise_error(DefinitionValidationError)
+    end
+  end
+
+  let(:version) { Gem::Version.new('5.5.27') }
+
+  describe '.installed_version' do
+    it 'should match 5.5.27 for mysql' do
+      definition.stub(:`).and_return '5.5.27'
+      definition.installed_version.should == version
+    end
+  end
+
+  describe '.check_version' do
+    it 'should be ~> 5.5 for mysql' do
+      definition.stub(:installed_version).and_return version
+      definition.check_version('~> 5.5').should be_true
+    end
+    it 'should be >= 5.3 for mysql' do
+      definition.stub(:installed_version).and_return version
+      definition.check_version('>= 5.3').should be_true
+    end
+    it 'should be <= 5.6 for mysql' do
+      definition.stub(:installed_version).and_return version
+      definition.check_version('<= 5.6').should be_true
+    end
+  end
+
+  describe '.is_running?' do
+    let(:running_return) do %q{yannick        65754   0.0  0.0  2432768    492 s000  R+    9:37PM   0:00.00 grep mysql
+yannick        65717   0.0  1.0  2666308  43300 s000  S     9:37PM   0:00.11 /usr/local/Cellar/mysql/5.5.27/bin/mysqld --basedir=/usr/local/Cellar/mysql/5.5.27 --datadir=/usr/local/var/mysql --plugin-dir=/usr/local/Cellar/mysql/5.5.27/lib/plugin --log-error=/usr/local/var/mysql/foobar.local.err --pid-file=/usr/local/var/mysql/foobar.local.pid
+yannick        65646   0.0  0.0  2433432   1072 s000  S     9:37PM   0:00.02 /bin/sh /usr/local/Cellar/mysql/5.5.27/bin/mysqld_safe --datadir=/usr/local/var/mysql --pid-file=/usr/local/var/mysql/foobar.local.pid}
+    end
+    let(:not_running_return) { %q{yannick        65754   0.0  0.0  2432768    492 s000  R+    9:37PM   0:00.00 grep mysql} }
+    it 'should be true if running' do
+      definition.stub(:`).and_return running_return
+      definition.is_running?.should be_true
+    end
+    it 'should be false if not running' do
+      definition.stub(:`).and_return not_running_return
+      definition.is_running?.should be_false
+    end
+  end
+
+  describe '.validates' do
+    it 'should raise an error if the version is wrong' do
+      definition.stub(:check_version).and_return false
+      definition.stub(:is_running?).and_return true
+      expect{ definition.validates("3.0") }.to raise_error(DefinitionValidationError)
+    end
+    it 'should raise an error if not running but must run arg' do
+      definition.stub(:check_version).and_return true
+      definition.stub(:is_running?).and_return false
+      expect{ definition.validates(nil, must_run: true) }.to raise_error(DefinitionValidationError)
+    end
+    it 'should be tru if everything is ok' do
+      definition.stub(:check_version).and_return true
+      definition.stub(:is_running?).and_return true
+      definition.validates("3.0", must_run: true).should be_true
+    end
+  end
+end
+

data/spec/lib/definitions_service_spec.rb

@@ -3,10 +3,11 @@ require 'chekku/errors'
 
 describe Chekku::DefinitionsService do
 
-  describe '#load_definitions_for' do
-    let(:definitions_service) { Chekku::DefinitionsService.new }
-    let(:definitions) { { 'mysql' => { 'existance' => 'which mysqld' }} }
+  let(:definition) { Chekku::Definition.new(name: 'mysql', executable: 'mysqld')}
+  let(:definitions) { [definition] }
+  let(:definitions_service) { Chekku::DefinitionsService.new }
 
+  describe '#load_definitions_for' do
     it 'should set definitions' do
       Chekku::Fetcher.stub(:fetch_for_chekkufile).with('blabla').and_return(definitions)
       expect { definitions_service.load_definitions_for('blabla') }
@@ -15,17 +16,14 @@ describe Chekku::DefinitionsService do
   end
 
   describe '#definition_for' do
-    let(:definitions) { { 'mysql' => { 'existance' => 'which mysqld' }} }
-
     context 'definitions are set' do
-      let(:definitions_service) { Chekku::DefinitionsService.new }
       before(:each) do
         definitions_service.definitions = definitions
       end
 
       context 'existing definition' do
         it 'should return the definition of the asked element' do
-          definitions_service.definition_for('mysql').should == definitions['mysql']
+          definitions_service.definition_for('mysql').should == definitions.first
         end
       end
 
@@ -37,7 +35,6 @@ describe Chekku::DefinitionsService do
     end
 
     context 'definitions are not set' do
-      let(:definitions_service) { Chekku::DefinitionsService.new }
       it 'should return nil' do
         definitions_service.definition_for('not-existing').should == nil
       end

data/spec/lib/definitions_spec.rb

@@ -0,0 +1,27 @@
+#encoding: utf-8
+require 'chekku/definitions'
+require 'chekku/definitions_service'
+require 'chekku/errors'
+
+describe Chekku::Definitions do
+
+  let(:definitions_service) { double(Chekku::DefinitionsService) }
+  let(:definitions) { Chekku::Definitions.new }
+  let(:definition) { Chekku::Definition.new(name: 'mysql', executable: 'mysqld') }
+
+  describe 'instance methods' do
+
+    describe '.get_definition' do
+      it 'should return the definition' do
+        definitions.definitions_service.stub(:definition_for).with('mysql').and_return(definition)
+        definitions.get_definition!('mysql').should == definition
+      end
+
+      it 'should raise an error if not found' do
+        definitions.definitions_service.stub(:definition_for).with('mysql').and_return(nil)
+        expect{ definitions.get_definition!('mysql') }.to raise_error(DefinitionNotFoundError)
+      end
+    end
+
+  end
+end

data/spec/lib/fetcher_spec.rb

@@ -9,10 +9,10 @@ describe Chekku::Fetcher do
       fetcher.dependencies_from_file
     end
 
-    it 'should return an object with methods corresponding to dependencies' do
-      dependencies_hash = { 'mysql' => { 'existance' => 'which mysqld' }}
+    it 'should return an array of definitions of dependencies' do
+      dependencies_hash = { 'mysql' => { 'executable' => 'mysqld' }}
       YAML.stub(:load_file).and_return(dependencies_hash)
-      fetcher.dependencies_from_file['mysql'].should == { 'existance' =>'which mysqld'}
+      fetcher.dependencies_from_file.first.name.should == 'mysql'
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chekku
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-01 00:00:00.000000000 Z
+date: 2012-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -80,15 +80,15 @@ files:
 - examples/def.yml
 - lib/chekku.rb
 - lib/chekku/checker.rb
+- lib/chekku/definition.rb
+- lib/chekku/definitions.rb
 - lib/chekku/definitions_service.rb
-- lib/chekku/dependency_checker.rb
-- lib/chekku/dsl.rb
 - lib/chekku/errors.rb
 - lib/chekku/fetcher.rb
 - lib/chekku/version.rb
+- spec/lib/definition_spec.rb
 - spec/lib/definitions_service_spec.rb
-- spec/lib/dependency_checker_spec.rb
-- spec/lib/dsl_spec.rb
+- spec/lib/definitions_spec.rb
 - spec/lib/fetcher_spec.rb
 - spec/spec_helper.rb
 homepage: http://ys.github.com/chekku
@@ -116,8 +116,8 @@ signing_key:
 specification_version: 3
 summary: ! 'Chekku: software dependencies checker'
 test_files:
+- spec/lib/definition_spec.rb
 - spec/lib/definitions_service_spec.rb
-- spec/lib/dependency_checker_spec.rb
-- spec/lib/dsl_spec.rb
+- spec/lib/definitions_spec.rb
 - spec/lib/fetcher_spec.rb
 - spec/spec_helper.rb

data/lib/chekku/dependency_checker.rb

@@ -1,51 +0,0 @@
-#encoding: utf-8
-class Chekku::DependencyChecker
-
-  attr_accessor :definitions_service
-  attr_accessor :definition
-
-  def self.with(definitions_service)
-    new definitions_service
-  end
-
-  def initialize(definitions_service)
-    @definitions_service = definitions_service
-  end
-
-  def chekku(name, version, args)
-    definition = get_and_check_definition! name
-    if exists? definition
-      "Checked #{name} [\033[32m✓\033[0m]"
-    else
-      "Checked #{name} [\033[31m✗\033[0m] I think you must install it!"
-    end
-  end
-
-  def get_and_check_definition!(name)
-    @definitions_service.definition_for(name) ||
-      raise(DefinitionNotFoundError, "#{name} definition not be found. Check ~/.chekku/def.yml")
-  end
-
-  def exists?(definition)
-    command = definition['executable']
-    verify_command!(command) && found?(command)
-  end
-
-  def verify_command!(command)
-    raise AppNameNotStringError, 'You need to use strings for app names' unless command.is_a?(String)
-    raise AppNameNotSaneError, "Sorry the app name '#{@current_app}' is not sane" unless sane?(command)
-    true
-  end
-
-  def found?(command)
-    system("which #{command} > /dev/null")
-  end
-
-  def sane?(command)
-    command == sanitize(command)
-  end
-
-  def sanitize(command)
-    command.gsub(/&|"|'|;|\s/, "")
-  end
-end

data/lib/chekku/dsl.rb

@@ -1,32 +0,0 @@
-require_relative 'dependency_checker'
-
-class Chekku::Dsl
-
-  attr_accessor :definitions_service
-
-  def self.evaluate(file)
-    new.eval_chekkufile(file)
-  end
-
-  def initialize
-    @definitions_service = Chekku::DefinitionsService.new
-    @definitions_service.load_definitions_for @chekkufile
-  end
-
-  def eval_chekkufile(file)
-    instance_eval(read_file(file))
-  rescue NoMethodError => e
-    puts "\033[31mERROR: Please verify the syntax of your Chekkufile"
-  end
-
-  def check(name, version = nil, args ={})
-    puts Chekku::DependencyChecker.with(@definitions_service).chekku(name, version, args)
-  rescue DefinitionsError => e
-    puts "\033[31mERROR: #{e.message}\033[0m\n"
-  end
-
-  def read_file(file)
-    File.open(file, "r") { |f| f.read }
-  end
-
-end

data/spec/lib/dependency_checker_spec.rb

@@ -1,129 +0,0 @@
-#encoding: utf-8
-require 'chekku/dependency_checker'
-require 'chekku/definitions_service'
-require 'chekku/errors'
-
-describe Chekku::DependencyChecker do
-
-
-  describe "#with" do
-    let(:definitions_service) { double(Chekku::DefinitionsService) }
-    let(:subject) { Chekku::DependencyChecker.with(definitions_service) }
-    it { should be_instance_of(Chekku::DependencyChecker) }
-    its(:definitions_service) { should == definitions_service }
-  end
-
-  describe 'instance methods' do
-    let(:checker) { Chekku::DependencyChecker.with(Chekku::DefinitionsService.new) }
-
-    describe ".sanitize" do
-      it "should not change a sane command" do
-        checker.sanitize("hello_you").should == "hello_you"
-      end
-
-      context "not sane commands" do
-        it "should remove &" do
-          checker.sanitize("hello&world").should == "helloworld"
-        end
-
-        it "should remove \"" do
-          checker.sanitize("hello\"world").should == "helloworld"
-        end
-
-        it "should remove '" do
-          checker.sanitize("hello'world").should == "helloworld"
-        end
-
-        it "should remove ;" do
-          checker.sanitize("hello;world").should == "helloworld"
-        end
-        it "should remove \s" do
-          checker.sanitize("hello world").should == "helloworld"
-        end
-      end
-    end
-
-    describe '.sane?' do
-      it "should be true with sane command" do
-        checker.sane?('ls').should be_true
-      end
-
-      it "should be false with not sane command" do
-        checker.sane?('ls & rm  ').should be_false
-      end
-    end
-
-    describe '.verify_command!' do
-      it 'should be ok with a sane string' do
-        checker.verify_command!('ls').should be_true
-      end
-
-      it 'should raise an error with symbol' do
-        expect { checker.verify_command!(:ls) }.to raise_error(AppNameNotStringError)
-      end
-
-      it 'should raise an error with not sane command' do
-        expect { checker.verify_command!('rm&') }.to raise_error(AppNameNotSaneError)
-      end
-    end
-
-    describe '.found?' do
-      it 'should be true for an existing command' do
-        checker.found?('ls').should be_true
-      end
-
-      it 'should be false for an existing command' do
-        checker.found?('lsrm').should be_false
-      end
-    end
-
-    describe '.exists?' do
-      let(:definition) { { 'executable' => 'mysql' } }
-      it 'should be true if command is valid and found' do
-        checker.stub(:verify_command!).with('mysql').and_return(true)
-        checker.stub(:found?).with('mysql').and_return(true)
-        checker.exists?(definition).should be_true
-      end
-
-      it 'should be false if command is invalid' do
-        checker.stub(:verify_command!).with('mysql').and_return(false)
-        checker.stub(:found?).with('mysql').and_return(true)
-        checker.exists?(definition).should be_false
-      end
-
-      it 'should be false if command is not found' do
-        checker.stub(:verify_command!).with('mysql').and_return(true)
-        checker.stub(:found?).with('mysql').and_return(false)
-        checker.exists?(definition).should be_false
-      end
-    end
-
-    describe '.get_and_check_definition' do
-      let(:definition) { { 'executable' => 'mysql' } }
-      it 'should return a hash with the definition' do
-        checker.definitions_service.stub(:definition_for).with('mysql').and_return(definition)
-        checker.get_and_check_definition!('mysql').should == definition
-      end
-
-      it 'should raise an error if not found' do
-        checker.definitions_service.stub(:definition_for).with('mysql').and_return(nil)
-        expect{ checker.get_and_check_definition!('mysql') }.to raise_error(DefinitionNotFoundError)
-      end
-    end
-
-    describe '.chekku' do
-      let(:definition) { { 'executable' => 'mysql' } }
-      it 'should if definition exists says ✓' do
-        checker.stub(:get_and_check_definition!).with('mysql').and_return(definition)
-        checker.stub(:exists?).with(definition).and_return(true)
-        checker.chekku('mysql', nil, nil).should == "Checked mysql [\033[32m✓\033[0m]"
-      end
-      it 'should if definition exists says x' do
-        checker.stub(:get_and_check_definition!).with('mysql').and_return(definition)
-        checker.stub(:exists?).with(definition).and_return(false)
-        checker.chekku('mysql', nil, nil).should == "Checked mysql [\033[31m✗\033[0m] I think you must install it!"
-      end
-    end
-
-  end
-end

data/spec/lib/dsl_spec.rb

@@ -1,6 +0,0 @@
-require 'chekku/dsl'
-
-describe Chekku::Dsl do
-  it 'should works' do
-  end
-end