iocheck 0.1.0

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Akira Hayakawa
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,41 @@
+# iocheck
+
+## Motivation "Make Refactoring Safe."
+There are thousand of softwares without test codes and 
+you do not have much time to add test programs to the software which disrespectively called legacy.
+Some kind of softwares, such as visualization softwares, are hard to test and these softwares are usually left untested.
+
+iocheck is in the opposite side of QuickCheck, a Haskell de-facto standard testing framework for purely functional codes.  
+Instead of checking the pure property of the softwares like QuickCheck does,
+iocheck checks the standard output with which any kind of programming languages equip.
+
+iocheck helps engineers working on legacy softwares who wants to refactor these software safely.
+If the software is written in COBOL or Fortran, it is OK. There is a hope called iocheck.
+All you have to do is write a main program to
+give some states of the program running to standard output,
+create test file, refactor a little bit and run iocheck to make sure no behavior changed.
+
+In summery, standard IO is equipped with any kind of languages even if they are almost out-dated.
+With iocheck testing framework, you can test legacy softwares usually written in those languages
+without any learning cost.
+
+## Installation
+iocheck can be installed from rubygems repository, just type
+
+```bash
+gem install iocheck
+```
+
+## Contributing to iocheck
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+## Copyright
+Copyright (c) 2011 Akira Hayakawa (@akiradeveloper). See LICENSE.txt for
+further details.
+

data/lib/iocheck.rb

@@ -0,0 +1,3 @@
+require_relative "iocheck/policy"
+require_relative "iocheck/test"
+require_relative "iocheck/tester"

data/lib/iocheck/policy.rb

@@ -0,0 +1,61 @@
+module IOCheck
+
+  class Policy
+    def initialize
+      @result = nil
+    end
+    attr_reader :result
+
+    # Expected -> Actual -> Either
+    def evaluate(expected, actual)
+      raise NoMethodError, "You must override this method."
+    end
+
+    def run!(expected, actual)
+      @result = evaluate(expected, actual)
+    end
+
+    class Success
+    end
+
+    class Failure
+      def initialize(log)
+        @log = log
+      end
+      attr_reader :log 
+    end
+
+    class Either
+      def initialize(pred, log)
+        if pred
+	  @stat = ::IOCheck::Policy::Success.new
+        else
+	  @stat = ::IOCheck::Policy::Failure.new(log)
+        end
+      end
+      def evaluate
+        @stat
+      end
+    end
+
+    class Block < Policy
+      def initialize(&blk)
+        super
+        @blk = blk
+      end
+  
+      def evaluate(expected, actual)
+        @blk.call(expected, actual)
+      end
+    end
+
+    def self.by_bytes
+      Block.new do |expected, actual|
+        # TODO: Better to show the diff to the user.
+        Either.new(
+          actual.bytes == expected.bytes,
+  	  "Bytes not exactly matched").evaluate
+      end
+    end
+  end # end of class Policy
+end # end of module IOCheck 

data/lib/iocheck/test.rb

@@ -0,0 +1,215 @@
+require_relative "policy"
+require_relative "tester"
+
+module IOCheck
+
+  def self.name(cmd)
+    cn = cmd.clone
+    if cn.start_with?( "./" )
+      cn[0..1] = "dotslash"
+    end
+    cn.split(" ").join("_")
+  end
+
+  def self.strip(bytes)
+    bytes.strip
+  end
+
+  def self.readfile(name)
+    dir = ::IOCheck::Env["dir"]
+    if self.include?(name, "#{dir}/lock") 
+      x = "#{dir}/lock/#{name}"
+    elsif self.include?(name, "#{dir}/unlock")
+      x = "#{dir}/unlock/#{name}"
+    else
+      raise ArgumentError, "readfile not found."
+    end
+    x
+  end
+
+  def self.writefile(name)
+    dir = ::IOCheck::Env["dir"]
+    "#{dir}/unlock/#{name}"
+  end
+
+  def self.include?(name, dir)
+    Dir.open(dir).each do |f|
+      return true if f == name
+    end   
+    return false
+  end
+
+  class Test
+    def initialize(cmd)
+      @command = Command.new(cmd)
+      @policies = [Policy.by_bytes]
+      @repeat = 1
+      @desc = ""
+    end
+
+    def repeat(n)
+      @repeat = n
+      self 
+    end
+
+    def describe(desc)
+      @desc = desc
+      self
+    end
+
+    def by(policy)
+      @policies << policy
+      self
+    end
+
+    def name
+      ::IOCheck.name( @command.cmd )
+    end
+
+    def locked?
+      true if ::IOCheck.include?(name, "#{::IOCheck::Env["dir"]}/lock")
+    end
+
+    def update!
+      return if locked?
+
+      do_run!
+      f = File.open( ::IOCheck.writefile(name), "w")
+      f.write( @command.actual.bytes )
+      f.close
+    end
+
+    def do_run!
+      @command.run!(@repeat)
+    end
+
+    def run!
+      do_run!
+      @policies.each do |p|
+        p.run!( expected, @command.actual )
+      end
+    end
+
+    def ready
+      RakeTask.new(self).create_tasks
+    end
+  
+    def show
+      n_success = 0
+      n_failure = 0
+      log = []
+      @policies.each do |p|
+        if p.result.class == ::IOCheck::Policy::Success
+	  n_success += 1
+	elsif p.result.class == ::IOCheck::Policy::Failure
+	  n_failure += 1
+	  log << p.result.log
+        else
+	  raise Error
+        end
+      end
+      puts "Test Name     : #{name}"
+      puts "Description   : #{@desc}"
+      puts "Minor Success : #{n_success}"
+      puts "Minor Failure : #{n_failure}"
+      puts "# Log --------:"
+      puts log.join("\n")
+    end
+
+  private
+
+    def expected
+      Expected.new(self)
+    end
+
+    class Command
+      def initialize(cmd)
+        @cmd = cmd
+        @actual = Actual.new
+      end
+      attr_reader :cmd, :actual
+    
+      def run!(repeat)
+        repeat.times do 
+          @actual << Actual::Result.new( @cmd )
+        end
+        @actual.repeat  = repeat
+      end
+
+      class Actual
+        def initialize
+          @results = []
+        end
+        attr_accessor :repeat
+  
+        def <<(result)
+	  @results << result
+        end
+        def bytes
+	  # TODO: assert all the results are equal in bytes?
+	  ::IOCheck.strip( @results[0].bytes )
+        end
+        class Result
+          def initialize(cmd)
+	    @cmd = cmd
+	    run!
+          end
+	  attr_reader :bytes
+        private  
+	  def run!
+	    # TODO: more things like measuring the time.
+	    x = `#{@cmd}`
+	    @bytes = ::IOCheck.strip( x )
+	  end
+        end # end of class Result
+      end # end of class Actual
+    end # end of class Command
+
+    class Expected
+      def initialize(test)
+        @test = test
+      end
+      def repeat
+        @test.repeat
+      end
+      def bytes
+        content = File.read( ::IOCheck.readfile(@test.name) )
+        ::IOCheck.strip( content )
+      end
+    end # end of class Expected
+
+    class RakeTask
+      def initialize(test)
+        @test = test
+      end
+      def create_tasks
+        create_update_task
+	create_run_task
+      end
+      def create_update_task
+        namespace "iocheck" do
+  	  namespace "update" do
+  	    task @test.name do
+  	      @test.update!
+            end
+  	  end
+	end
+      end
+      def create_run_task
+        namespace "iocheck" do
+	  task @test.name do
+	    @test.run!
+	    @test.show
+	  end
+	end
+      end
+    end # end of class RakeTask
+  end # end of class Test
+end # end of module IOCheck
+
+if __FILE__ == $0
+  p ::IOCheck.name("tree")
+  p ::IOCheck.writefile("tree")
+  p ::IOCheck.readfile("tree")
+  p ::IOCheck.strip("\n aa bbb\n  ccff \n ")
+end

data/lib/iocheck/tester.rb

@@ -0,0 +1,74 @@
+module IOCheck
+
+  Env = {}
+  ::IOCheck::Env["dir"] = "./iocheck"
+  
+  class Tester
+  
+    def initialize
+      @tests = []
+    end
+    
+    def <<(test)
+      @tests << test
+    end
+  
+    def run!
+      @tests.each { |t| t.run! }
+    end
+
+    def update!
+      @tests.each { |t| t.update! }
+    end
+  
+    def ready
+      @tests.each do |t|
+        t.ready
+      end
+      namespace "iocheck" do
+        task "update" => @tests.map { |t| "iocheck:update:#{t.name}" }
+      end
+      task "iocheck" do
+        run!
+	show
+      end
+      create_lock_tasks
+    end
+
+    def create_lock_tasks
+      locked = @tests.select { |t| t.locked? }
+      unlocked = @tests.select { |t| ! t.locked? }
+      dir = ::IOCheck::Env["dir"]
+
+      namespace "iocheck" do
+        task "lock" => unlocked.map { |t| "iocheck:lock:#{t.name}" }
+        unlocked.each do  |t|
+	  namespace "lock" do
+	    task t.name do
+	      dest = dir + "/" + "lock"
+	      mv ::IOCheck.readfile(t.name), dest
+            end
+	  end
+        end
+	task "unlock" => locked.map { |t| "iocheck:unlock:#{t.name}" }
+	locked.each do |t|
+          namespace "unlock" do
+	    task t.name do
+	      dest = dir + "/" + "unlock"
+	      mv ::IOCheck.readfile(t.name), dest
+	    end
+	  end
+	end
+      end
+    end
+
+  private
+    def show
+      # TODO: This is a temporary implementation.
+      @tests.each do |t|
+        t.show
+      end
+      # TODO: Here, summary result should be written.
+    end
+  end # end of class Tester
+end # end of module IOCheck

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: iocheck
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Akira Hayakawa
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-06 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &21844540 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+  type: :development
+  prerelease: false
+  version_requirements: *21844540
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &21844060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *21844060
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &21843580 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.4
+  type: :development
+  prerelease: false
+  version_requirements: *21843580
+- !ruby/object:Gem::Dependency
+  name: rcov
+  requirement: &21755800 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *21755800
+description: Make refactoring for legacy softwares safe.
+email: ruby.wktk@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- lib/iocheck.rb
+- lib/iocheck/policy.rb
+- lib/iocheck/test.rb
+- lib/iocheck/tester.rb
+- LICENSE.txt
+- README.md
+homepage: http://github.com/akiradeveloper/iocheck
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -2015204035547287083
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: IO-based testing framework.
+test_files: []