jets 0.0.1 → 0.2.0

data/spec/fixtures/project/bin/jets

@@ -0,0 +1,22 @@
+#!/bin/bash
+
+set -e
+
+# Figure out where this script is located.
+PROJECTDIR="`dirname \"$0\"`"
+PROJECTDIR="`cd \"$PROJECTDIR/..\" && pwd`"
+
+# Tell Bundler where the Gemfile and gems are.
+# IMPORTANT: the Gemfile must be in the same bundled/gems folder
+export BUNDLE_GEMFILE="$PROJECTDIR/bundled/gems/Gemfile"
+unset BUNDLE_IGNORE_CONFIG
+
+# Run the actual app using the bundled Ruby interpreter, with Bundler activated.
+os=$(uname)
+if [[ "$os" == 'Darwin' ]]; then
+  # macosx ruby for development
+  exec jets "$@"
+else
+  # bundled ruby for Lambda
+  exec "$PROJECTDIR/bundled/ruby/bin/ruby" -rbundler/setup "$PROJECTDIR/bundled/gems/ruby/2.2.0/bin/jets" "$@"
+fi

data/spec/fixtures/project/config/routes.rb

@@ -0,0 +1,6 @@
+get  "posts/:id", to: "posts#show"
+post "posts", to: "posts#create"
+put  "posts", to: "posts#update"
+delete  "posts", to: "posts#destroy"
+any "posts/hot", to: "posts#hot"
+resources :posts

data/spec/fixtures/project/handlers/controllers/posts.js

@@ -0,0 +1,212 @@
+'use strict';
+
+const spawn = require('child_process').spawn;
+
+// Once hooked up to API Gateway can use the curl command to test:
+// curl -s -X POST -d @event.json https://endpoint | jq .
+
+// Filters out lines so only the error lines remain.
+// Uses the "RubyError: " marker to find the starting error lines.
+//
+// Input: String
+// random line
+// RubyError: RuntimeError: error in submethod
+// line1
+// line2
+// line3
+//
+// Output: String
+// RubyError: RuntimeError: error in submethod
+// line1
+// line2
+// line3
+function filterErrorLines(text) {
+  var lines = text.split("\n")
+  var markerIndex = lines.findIndex(line => line.startsWith("RubyError: ") )
+  lines = lines.filter((line, index) => index >= markerIndex )
+  return lines.join("\n")
+}
+
+// Produces an Error object that displays in the AWS Lambda test console nicely.
+// The backtrace are the ruby lines, not the nodejs shim error lines.
+// The json payload in the Lambda console looks something like this:
+//
+// {
+//   "errorMessage": "RubyError: RuntimeError: error in submethod",
+//   "errorType": "RubyError",
+//   "stackTrace": [
+//     [
+//       "line1",
+//       "line2",
+//       "line3"
+//     ]
+//   ]
+// }
+//
+// Input: String
+// RubyError: RuntimeError: error in submethod
+// line1
+// line2
+// line3
+//
+// Output: Error object
+// { RubyError: RuntimeError: error in submethod
+// line1
+// line2
+// line3 name: 'RubyError' }
+function customError(text) {
+  text = filterErrorLines(text) // filter for error lines only
+  var lines = text.split("\n")
+  var message = lines[0]
+  var error = new Error(message)
+  error.name = message.split(':')[0]
+  error.stack = lines.slice(0, lines.length-1) // drop final empty line
+                  .map(e => e.replace(/^\s+/g,'')) // trim leading whitespaces
+                  .join("\n")
+  return error
+}
+
+
+module.exports.create = (event, context, callback) => {
+  // Command: bin/jets process controller [event] [context] [handler]
+  var args = [
+    "process",
+    "controller",     // controller (singular)
+    JSON.stringify(event),      // event
+    JSON.stringify(context),    // context
+    "handlers/controllers/posts.create" // IE: handlers/controllers/posts.update
+  ]
+  var ruby = spawn("bin/jets", args);
+
+  // string concatation in javascript is faster than array concatation
+  // http://bit.ly/2gBMDs6
+  var stdout_buffer = ""; // stdout buffer
+  // In the processor_command we do NOT call puts directly and write to stdout
+  // because it will mess up the eventual response that we want API Gateway to
+  // process.
+  // The Lambda prints out function to whatever the return value the ruby method
+  ruby.stdout.on('data', function(data) {
+    // Not using console.log because it decorates output with a newline.
+    //
+    // Uncomment process.stdout.write to see stdout streamed for debugging.
+    // process.stdout.write(data)
+    stdout_buffer += data;
+  });
+
+  // react to potential errors
+  var stderr_buffer = "";
+  ruby.stderr.on('data', function(data) {
+    // not using console.error because it decorates output with a newline
+    stderr_buffer += data
+    process.stderr.write(data)
+  });
+
+  //finalize when ruby process is done.
+  ruby.on('close', function(exit_code) {
+    // http://docs.aws.amazon.com/lambda/latest/dg/nodejs-prog-model-handler.html#nodejs-prog-model-handler-callback
+
+    // succcess
+    if (exit_code == 0) {
+      var result
+      try {
+        result = JSON.parse(stdout_buffer)
+      } catch(e) {
+        // if json cannot be parse assume simple text output intended
+        process.stderr.write("WARN: error parsing json, assuming plain text is desired.")
+        result = stdout_buffer
+      }
+      callback(null, result);
+
+      // callback(null, stdout_buffer);
+    } else {
+
+      // TODO: if this works, allow a way to not decorate the error in case
+      // it actually errors in javascript land
+      // Customize error object with ruby error info
+      var error = customError(stderr_buffer)
+      callback(error);
+      // console.log("error!")
+    }
+  });
+}
+
+module.exports.update = (event, context, callback) => {
+  // Command: bin/jets process controller [event] [context] [handler]
+  var args = [
+    "process",
+    "controller",     // controller (singular)
+    JSON.stringify(event),      // event
+    JSON.stringify(context),    // context
+    "handlers/controllers/posts.update" // IE: handlers/controllers/posts.update
+  ]
+  var ruby = spawn("bin/jets", args);
+
+  // string concatation in javascript is faster than array concatation
+  // http://bit.ly/2gBMDs6
+  var stdout_buffer = ""; // stdout buffer
+  // In the processor_command we do NOT call puts directly and write to stdout
+  // because it will mess up the eventual response that we want API Gateway to
+  // process.
+  // The Lambda prints out function to whatever the return value the ruby method
+  ruby.stdout.on('data', function(data) {
+    // Not using console.log because it decorates output with a newline.
+    //
+    // Uncomment process.stdout.write to see stdout streamed for debugging.
+    // process.stdout.write(data)
+    stdout_buffer += data;
+  });
+
+  // react to potential errors
+  var stderr_buffer = "";
+  ruby.stderr.on('data', function(data) {
+    // not using console.error because it decorates output with a newline
+    stderr_buffer += data
+    process.stderr.write(data)
+  });
+
+  //finalize when ruby process is done.
+  ruby.on('close', function(exit_code) {
+    // http://docs.aws.amazon.com/lambda/latest/dg/nodejs-prog-model-handler.html#nodejs-prog-model-handler-callback
+
+    // succcess
+    if (exit_code == 0) {
+      var result
+      try {
+        result = JSON.parse(stdout_buffer)
+      } catch(e) {
+        // if json cannot be parse assume simple text output intended
+        process.stderr.write("WARN: error parsing json, assuming plain text is desired.")
+        result = stdout_buffer
+      }
+      callback(null, result);
+
+      // callback(null, stdout_buffer);
+    } else {
+
+      // TODO: if this works, allow a way to not decorate the error in case
+      // it actually errors in javascript land
+      // Customize error object with ruby error info
+      var error = customError(stderr_buffer)
+      callback(error);
+      // console.log("error!")
+    }
+  });
+}
+
+
+// for local testing
+if (process.platform == "darwin") {
+  // fake event and context
+  var event = {"hello": "world"}
+  // var event = {"body": {"hello": "world"}} // API Gateway wrapper structure
+  var context = {"fake": "context"}
+  module.exports.create(event, context, (error, message) => {
+    console.error("\nLOCAL TESTING OUTPUT")
+    if (error) {
+      console.error("error message: %o", error)
+    } else {
+      console.error("success message %o", message)
+      // console.log(JSON.stringify(message)) // stringify
+    }
+  })
+}

data/spec/lib/cli_spec.rb

@@ -7,13 +7,14 @@ require "spec_helper"
 #   $ rake clean:vcr ; time rake
 describe Jets::CLI do
   before(:all) do
-    @args = "--from Tung"
+    @args = "--noop"
   end
 
   describe "jets" do
-    it "should hello world" do
-      out = execute("bin/jets hello world #{@args}")
-      expect(out).to include("from: Tung\nHello world")
+    it "build" do
+      out = execute("bin/jets build #{@args}")
+      # puts out
+      expect(out).to include("Building project")
     end
   end
 end

data/spec/lib/jets/base_controller_spec.rb

@@ -0,0 +1,18 @@
+require "spec_helper"
+
+# For testing lambda_function_names
+class FakeController < Jets::BaseController
+  def handler1; end
+  def handler2; end
+end
+
+describe Jets::BaseController do
+  describe "lambda_functions" do
+    it "should only list public user defined methods" do
+      controller = FakeController.new(nil, nil)
+      expect(controller.lambda_functions).to eq(
+        [:handler1, :handler2]
+      )
+    end
+  end
+end

data/spec/lib/jets/build/handler_generator_spec.rb

@@ -0,0 +1,20 @@
+require_relative "../../../spec_helper"
+
+describe Jets::Build::HandlerGenerator do
+  let(:generator) do
+    Jets::Build::HandlerGenerator.new(
+      "PostsController",
+      :create, :update
+    )
+  end
+
+  describe "HandlerGenerator" do
+    it "generates a node shim for lambda" do
+      generator.run
+      content = IO.read("#{Jets.root}handlers/controllers/posts.js")
+      expect(content).to include("handlers/controllers/posts.create") # handler
+      expect(content).to include("exports.create") # function
+      expect(content).to include("exports.update") # function
+    end
+  end
+end

data/spec/lib/jets/build/lambda_deducer_spec.rb

@@ -0,0 +1,15 @@
+require_relative "../../../spec_helper"
+
+describe Jets::Build::LambdaDeducer do
+  let(:deducer) do
+    Jets::Build::LambdaDeducer.new("app/controllers/posts_controller.rb")
+  end
+
+  describe "LambdaDeducer" do
+    it "deduces lambda js info" do
+      expect(deducer.class_name).to eq("PostsController")
+      expect(deducer.functions).to eq([:create, :update])
+    end
+  end
+end
+

data/spec/lib/jets/build_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+
+describe Jets::Build do
+  before(:each) do
+    FileUtils.rm_f("spec/fixtures/project/handlers/controllers/posts.js")
+  end
+  let(:build) do
+    Jets::Build.new(noop: true)
+  end
+
+  describe "Build" do
+    it "#controller_paths" do
+      expect(build.controller_paths).to eq(["app/controllers/posts_controller.rb"])
+    end
+
+    it "builds handlers javascript files" do
+      build.build
+      file_exist = File.exist?("#{Jets.root}handlers/controllers/posts.js")
+      expect(file_exist).to be true
+    end
+
+    # Would be nice to be able to automate testing the shim
+    # context "node shim" do
+    #   it "posts create should return json" do
+    #     # build.build
+    #     # Dir.chdir(ENV["PROJECT_ROOT"]) do
+    #       out = execute("cd #{ENV["PROJECT_ROOT"]} && node handlers/controllers/posts.js")
+    #       puts out
+    #     # end
+    #   end
+    # end
+  end
+end
+

data/spec/lib/jets/cfn/builder_spec.rb

@@ -0,0 +1,18 @@
+require_relative "../../../spec_helper"
+
+describe Jets::Cfn::Builder do
+  let(:cfn) do
+    Jets::Cfn::Builder.new(CommentsController)
+  end
+
+  describe "Cfn::Builder" do
+    it "adds functions to resources" do
+      cfn.compose!
+      expect(cfn.template[:Resources].keys).to eq(
+        ["CommentsControllerCreate", "CommentsControllerUpdate"]
+      )
+      puts cfn.text
+      IO.write("tmp/template.yml", cfn.text)
+    end
+  end
+end

data/spec/lib/jets/cfn/namer_spec.rb

@@ -0,0 +1,16 @@
+require_relative "../../../spec_helper"
+
+describe Jets::Cfn::Namer do
+  let(:namer) do
+    Jets::Cfn::Namer.new(CommentsController, :create)
+  end
+
+  describe "Cfn::Namer" do
+    it "creates names appropriate for CloudFormation" do
+      expect(namer.handler).to eq "handlers/controllers/comments.create"
+      expect(namer.logical_id).to eq "CommentsControllerCreate"
+      expect(namer.function_name).to eq "proj-dev-comments-controller-create"
+      expect(namer.s3_key).to include("jets/cfn-templates/dev/")
+    end
+  end
+end

data/spec/lib/jets/process/controller_processor_spec.rb

@@ -0,0 +1,22 @@
+require_relative "../../../spec_helper"
+
+describe Jets::Process::ControllerProcessor do
+  before(:all) do
+    @event = { "we" => "love", "using" => "Lambda" }
+    @context = {"test" => "1"}
+  end
+  let(:processor) do
+    Jets::Process::ControllerProcessor.new(
+      JSON.dump(@event),
+      JSON.dump(@context),
+      'handlers/controllers/posts.create' # handler
+    )
+  end
+
+  describe "ControllerProcessor" do
+    it "find public_instance_methods" do
+      processor.run
+      expect(processor.event).to eq(@event)
+    end
+  end
+end

data/spec/lib/jets/process/infer_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+describe Jets::Process::ProcessorDeducer do
+  describe "ProcessorDeducer" do
+    let(:deducer) { Jets::Process::ProcessorDeducer.new(handle) }
+
+    context("controller") do
+      let(:handle) { "handlers/controllers/posts.create" }
+      it "deduces processor info" do
+        expect(deducer.controller[:path]).to include "app/controllers/posts_controller.rb"
+        expect(deducer.controller[:code]).to eq "PostsController.new(event, context).create"
+      end
+    end
+
+    context("function") do
+      let(:handle) { "handlers/functions/posts.create" }
+      it "deduces processor info" do
+        expect(deducer.function[:path]).to include "app/functions/posts.rb"
+        expect(deducer.function[:code]).to eq "create(event, context)"
+      end
+    end
+
+  end
+end

data/spec/lib/jets/process_spec.rb

@@ -0,0 +1,18 @@
+require_relative "../../spec_helper"
+
+describe Jets::Process do
+  before(:all) do
+    # @args = "--noop --project-root spec/fixtures/my_project"
+    @args = '\'{ "we" : "love", "using" : "Lambda" }\' \'{"test": "1"}\' "handlers/controllers/posts.create"'
+  end
+
+  describe "jets process" do
+    it "controller [event] [context] [handler]" do
+      out = execute("bin/jets process controller #{@args}")
+      # pp out # uncomment to debug
+      data = JSON.parse(out)
+      expect(data["statusCode"]).to eq 200
+      expect(data["body"]).to eq({"we"=>"love", "using"=>"Lambda","a"=>"create"})
+    end
+  end
+end