oration 0.0.1

data/test/test_generator.rb

@@ -0,0 +1,206 @@
+# Programmer: Chris Bunch
+
+
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'generator'
+
+require 'test/unit'
+
+
+class DoNothingGenerator
+  def self.does_nothing(a, b, c)
+  end
+end
+
+
+class GetPythonFunctionFakeFile
+  def self.open(filename)
+    case filename
+    when "test 1"
+      return TEST_PYTHON_FILE1
+    when "test 2"
+      return TEST_PYTHON_FILE2
+    when "test 3"
+      return TEST_PYTHON_FILE3
+    else
+      abort("filename was not an acceptable parameter")
+    end
+  end
+end
+
+
+PY_FUNCTION = <<PY
+def print_hello_world():
+  print "hello world!"
+PY
+
+TEST_PYTHON_FILE1 = <<PY
+#{PY_FUNCTION}
+PY
+
+TEST_PYTHON_FILE2 = <<PY
+def print_hello_world():
+  sleep(1)
+  for i in range(5):
+    print "hello world!"
+PY
+
+TEST_PYTHON_FILE3 = <<PY
+import random
+import sys
+import os
+
+#{PY_FUNCTION}
+PY
+
+
+class GetGoFunctionFakeFile
+  def self.open(filename)
+    case filename
+    when "test 1"
+      return TEST_GO_FILE1
+    when "test 2"
+      return TEST_GO_FILE2
+    when "test 3"
+      return TEST_GO_FILE3
+    else
+      abort("filename was not an acceptable parameter")
+    end
+  end
+end
+
+
+GO_FUNCTION = <<GO
+func PrintHelloWorld() string {
+  return "Hello world!"
+}
+GO
+
+TEST_GO_FILE1 = <<GO
+#{GO_FUNCTION}
+GO
+
+TEST_GO_FILE2 = <<GO
+func PrintHelloWorld() string {
+  all := ""
+  for i := 0; i < 5; i++ {
+      all += "Hello world!\n"
+  }
+  return all
+}
+GO
+
+GO_FUNCTION_3 = <<GO
+func PrintHelloWorld() string {
+  return fmt.Sprintf("Hello world %d", 1)
+}
+GO
+
+TEST_GO_FILE3 = <<GO
+import fmt
+
+#{GO_FUNCTION_3}
+GO
+
+
+class GeneratorFakeFile
+  def self.expand_path(path)
+    return path
+  end
+
+  def self.open(location, mode=nil)
+    return ""
+  end
+end
+
+
+class TestGenerator < Test::Unit::TestCase
+  def test_generate_app
+    # Slip in a fake method that doesn't do anything since we only want to
+    # test the generate_app method, and not methods that actually create a
+    # Python or Go application.
+    function = "blarg"
+    output_dir = "output_dir"
+    do_nothing_method = DoNothingGenerator.method(:does_nothing)
+
+    # c files aren't supported, so this should fail
+    assert_raise(SystemExit) {
+      Generator.generate_app("boo.c", function, output_dir, do_nothing_method,
+        do_nothing_method)
+    }
+
+    # files with no extension aren't supported, so this should fail
+    assert_raise(SystemExit) {
+      Generator.generate_app("boo", function, output_dir, do_nothing_method,
+        do_nothing_method)
+    }
+
+    # python files are supported, so this should succeed
+    assert_nothing_raised(SystemExit) {
+      Generator.generate_app("boo.py", function, output_dir, do_nothing_method,
+        do_nothing_method)
+    }
+
+    # go files are supported, so this should succeed
+    assert_nothing_raised(SystemExit) {
+      Generator.generate_app("boo.go", function, output_dir, do_nothing_method,
+        do_nothing_method)
+    }
+  end
+
+  def test_get_python_function
+    main_file1 = "test 1"
+    function_name = "print_hello_world"
+    assert_equal(PY_FUNCTION.strip, Generator.get_python_function(main_file1,
+      function_name, file=GetPythonFunctionFakeFile).strip)
+
+    main_file2 = "test 2"
+    assert_equal(TEST_PYTHON_FILE2.strip, Generator.get_python_function(
+      main_file2, function_name, file=GetPythonFunctionFakeFile).strip)
+
+    main_file3 = "test 3"
+    assert_equal(PY_FUNCTION.strip, Generator.get_python_function(main_file3,
+      function_name, file=GetPythonFunctionFakeFile).strip)
+  end
+
+  def test_write_python_app_yaml
+    assert_nothing_raised(SystemExit) {
+      Generator.write_python_app_yaml_file("boo", "/tmp/boo", GeneratorFakeFile)
+    }
+  end
+
+  def test_write_python_main_py
+    assert_nothing_raised(SystemExit) {
+      Generator.write_python_cicero_code("def boo():\n  print 'hello world!'",
+        "boo", "/tmp/boo", GeneratorFakeFile)
+    }
+  end
+
+  def test_get_go_function
+    main_file1 = "test 1"
+    function_name = "PrintHelloWorld"
+    assert_equal(GO_FUNCTION.strip, Generator.get_go_function(main_file1,
+      function_name, file=GetGoFunctionFakeFile).strip)
+
+    main_file2 = "test 2"
+    assert_equal(TEST_GO_FILE2.strip, Generator.get_go_function(main_file2,
+      function_name, file=GetGoFunctionFakeFile).strip)
+
+    main_file3 = "test 3"
+    assert_equal(GO_FUNCTION_3.strip, Generator.get_go_function(main_file3,
+      function_name, file=GetGoFunctionFakeFile).strip)
+  end
+
+  def test_write_go_app_yaml
+    assert_nothing_raised(SystemExit) {
+      Generator.write_go_app_yaml_file("boo", "/tmp/boo", GeneratorFakeFile)
+    }
+  end
+
+  def test_write_go_main_go
+    assert_nothing_raised(SystemExit) {
+      Generator.write_go_cicero_code("func Boo() string { return \"2\" }",
+        "boo", "/tmp/boo", GeneratorFakeFile)
+    }
+  end
+end

data/test/test_oration.rb

@@ -0,0 +1,53 @@
+# Programmer: Chris Bunch
+
+$:.unshift File.join(File.dirname(__FILE__), "..", "bin")
+require 'oration'
+
+require 'test/unit'
+
+
+class FakeFile
+  def self.exists?(file_name)
+    if file_name.include?("good") or file_name.include?("exists")
+      return true
+    else
+      return false
+    end
+  end
+
+  def self.open(file_name)
+    return "def good-function-name():\n  print 'hello world!'"
+  end
+end
+
+
+class TestOration < Test::Unit::TestCase
+  def test_validate_arguments
+    # test when there are the wrong number of args
+    bad_args_1 = %w{}
+    bad_args_2 = %w{boo.go}
+    bad_args_3 = %w{boo.go boo}
+    bad_args_4 = %w{boo.go boo boo boo}
+    [bad_args_1, bad_args_2, bad_args_3, bad_args_4].each { |args|
+      assert_raise(SystemExit) { validate_arguments(args, FakeFile) }
+    }
+
+    # test when the file in question doesn't exist
+    bad_args_5 = %w{doesnt-exist.go boo output-dir}
+    assert_raise(SystemExit) { validate_arguments(bad_args_5, FakeFile) }
+    
+    # test when the function to be used doesn't exist in that file
+    bad_args_6 = %w{good-file.go bad-function-name output-dir}
+    assert_raise(SystemExit) { validate_arguments(bad_args_6, FakeFile) }
+
+    # test when the output-dir specified already exists
+    bad_args_7 = %w{good-file.go good-function-name output-dir-exists}
+    assert_raise(SystemExit) { validate_arguments(bad_args_7, FakeFile) }
+
+    # test when the user gives us a file that exists with the named function
+    good_args = %w{good-file.go good-function-name output-dir}
+    assert_nothing_raised(SystemExit) {
+      validate_arguments(good_args, FakeFile)
+    }
+  end
+end

data/test/ts_all.rb

@@ -0,0 +1,5 @@
+# Programmer: Chris Bunch
+
+$:.unshift File.join(File.dirname(__FILE__))
+require 'test_oration'
+require 'test_generator'

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification 
+name: oration
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Chris Bunch
+autorequire: oration
+bindir: bin
+cert_chain: []
+
+date: 2011-12-01 00:00:00 -08:00
+default_executable: oration
+dependencies: []
+
+description: "    Oration converts a function written in Python or Go into a Google App Engine\n    application that conforms to the Cicero API, allowing the given function to\n    be automatically executed over Google App Engine or AppScale in an\n    embarrassingly parallel fashion.\n"
+email: appscale_community@googlegroups.com
+executables: 
+- oration
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+files: 
+- bin/oration
+- bin/oration.rb
+- doc/Object.html
+- doc/js/jquery.js
+- doc/js/darkfish.js
+- doc/js/quicksearch.js
+- doc/js/thickbox-compressed.js
+- doc/lib/generator_rb.html
+- doc/index.html
+- doc/bin/oration_rb.html
+- doc/bin/oration.html
+- doc/Generator.html
+- doc/images/wrench.png
+- doc/images/loadingAnimation.gif
+- doc/images/find.png
+- doc/images/page_white_text.png
+- doc/images/zoom.png
+- doc/images/plugin.png
+- doc/images/brick_link.png
+- doc/images/page_green.png
+- doc/images/brick.png
+- doc/images/date.png
+- doc/images/bug.png
+- doc/images/bullet_black.png
+- doc/images/page_white_width.png
+- doc/images/tag_green.png
+- doc/images/macFFBgHack.png
+- doc/images/wrench_orange.png
+- doc/images/ruby.png
+- doc/images/bullet_toggle_plus.png
+- doc/images/package.png
+- doc/images/bullet_toggle_minus.png
+- doc/created.rid
+- lib/generator.rb
+- test/test_generator.rb
+- test/test_oration.rb
+- test/ts_all.rb
+- LICENSE
+has_rdoc: true
+homepage: http://appscale.cs.ucsb.edu
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.4.2
+signing_key: 
+specification_version: 3
+summary: Generates Cicero-ready Google App Engine apps from regular code
+test_files: []
+