RubyGems - traceur-rb - Versions diffs - 0.0.1 - Mend

traceur-rb 0.0.1

Files changed (255) hide show

data/vendor/node_modules/traceur/node_modules/q-io/spec/http-apps/directory-list-spec.js ADDED Viewed

@@ -0,0 +1,86 @@
+require("../lib/jasmine-promise");
+var Http = require("../../http");
+var Apps = require("../../http-apps");
+var FS = require("../../fs");
+describe("directory lists", function () {
+    it("should be fine in plain text", function () {
+        var fixture = FS.join(module.directory || __dirname, "fixtures");
+        var app = new Apps.Chain()
+        .use(Apps.Cap)
+        .use(Apps.ListDirectories)
+        .use(function () {
+            return Apps.FileTree(fixture);
+        })
+        .end()
+        return Http.Server(app)
+        .listen(0)
+        .then(function (server) {
+            var port = server.address().port;
+            return Http.read({
+                url: "http://127.0.0.1:" + port + "/",
+                headers: {
+                    accept: "text/plain"
+                },
+                charset: 'utf-8'
+            })
+            .then(function (content) {
+                expect(content).toEqual("01234.txt\n1234.txt\n5678.txt\n9012/\n");
+            })
+            .finally(server.stop);
+        });
+    });
+    it("should be fine in html", function () {
+        var fixture = FS.join(module.directory || __dirname, "fixtures");
+        var app = new Apps.Chain()
+        .use(Apps.Cap)
+        .use(Apps.HandleHtmlFragmentResponses)
+        .use(Apps.ListDirectories)
+        .use(function () {
+            return Apps.FileTree(fixture);
+        })
+        .end()
+        return Http.Server(app)
+        .listen(0)
+        .then(function (server) {
+            var port = server.address().port;
+            return Http.read({
+                url: "http://127.0.0.1:" + port + "/",
+                headers: {
+                    accept: "text/html"
+                },
+                charset: 'utf-8'
+            })
+            .then(function (content) {
+                expect(content).toEqual(
+                    "<!doctype html>\n" +
+                    "<html>\n" +
+                    "    <head>\n" +
+                    "        <title>Directory Index</title>\n" +
+                    "    </head>\n" +
+                    "    <body>\n" +
+                    "        <ul class=\"directory-index\">\n" +
+                    "            <li class=\"entry file\"><a href=\"01234.txt\">01234.txt</a></li>\n" +
+                    "            <li class=\"entry file\"><a href=\"1234.txt\">1234.txt</a></li>\n" +
+                    "            <li class=\"entry file\"><a href=\"5678.txt\">5678.txt</a></li>\n" +
+                    "            <li class=\"entry directory\"><a href=\"9012/\">9012/</a></li>\n" +
+                    "        </ul>\n" +
+                    "    </body>\n" +
+                    "</html>\n"
+                );
+            })
+            .finally(server.stop);
+        });
+    });
+});

data/vendor/node_modules/traceur/node_modules/q-io/spec/http-apps/fixtures/01234.txt ADDED Viewed

	@@ -0,0 +1 @@
1	+ 01234.txt

data/vendor/node_modules/traceur/node_modules/q-io/spec/http-apps/fixtures/1234.txt ADDED Viewed

	@@ -0,0 +1 @@
1	+ 1234

data/vendor/node_modules/traceur/node_modules/q-io/spec/http-apps/fixtures/5678.txt ADDED Viewed

File without changes

data/vendor/node_modules/traceur/node_modules/q-io/spec/http-apps/fixtures/9012/3456.txt ADDED Viewed

File without changes

data/vendor/node_modules/traceur/node_modules/q-io/spec/http-apps/hosts-spec.js ADDED Viewed

@@ -0,0 +1,49 @@
+require("../lib/jasmine-promise");
+var Q = require("q");
+var Http = require("../../http");
+var Negotiate = require("../../http-apps/negotiate");
+var Content = require("../../http-apps/content");
+describe("http host negotiation", function () {
+    it("should work", function () {
+        return Http.Server(Negotiate.Host({
+            "localhost:999": function (request) {
+                throw new Error("Should not get here");
+            },
+            "127.0.0.1:999": function (request) {
+                throw new Error("Should not get here");
+            },
+            "localhost": function (request) {
+                return Content.ok("Hello, Localhost");
+            },
+            "127.0.0.1": function (request) {
+                return Content.ok("Hello, 127.0.0.1");
+            }
+        }))
+        .listen(0)
+        .then(function (server) {
+            var port = server.address().port;
+            return Q.fcall(function () {
+                return Http.read({
+                    "url": "http://localhost:" + port,
+                    "charset": "utf-8"
+                })
+                .then(function (result) {
+                    expect(result).toEqual("Hello, Localhost");
+                });
+            })
+            .then(function () {
+                return Http.read({
+                    "url": "http://127.0.0.1:" + port,
+                    "charset": "utf-8"
+                })
+                .then(function (result) {
+                    expect(result).toEqual("Hello, 127.0.0.1");
+                });
+            })
+            .finally(server.stop);
+        });
+    });
+});

data/vendor/node_modules/traceur/node_modules/q-io/spec/http-apps/interpret-range-spec.js ADDED Viewed

@@ -0,0 +1,47 @@
+// http://labs.apache.org/webarch/http/draft-fielding-http/p5-range.html#range.units
+var Apps = require("../../http-apps/fs");
+var size = 10000;
+var tests = [
+    {
+        description: "The first 500 bytes (byte offsets 0-499, inclusive)",
+        input: "bytes=0-499",
+        oracle: {begin: 0, end: 500}
+    },
+    {
+        description: "The second 500 bytes (byte offsets 500-999, inclusive)",
+        input: "bytes=500-999",
+        oracle: {begin: 500, end: 1000}
+    },
+    {
+        description: "The initial 500 bytes with 0 elided",
+        input: "bytes=-499",
+        oracle: {begin: 0, end: 500}
+    },
+    {
+        description: "The final 500 bytes with final elided (byte offsets 9500-9999, inclusive)",
+        input: "bytes=9500-",
+        oracle: {begin: 9500, end: 10000}
+    },
+    {
+        description: "Legal but not canonical specification of the second 500 bytes (byte offsets 500-999, inclusive)",
+        input: "bytes=500-600,601-999",
+        oracle: {begin: 500, end: 1000}
+    },
+    {
+        description: "Legal but not canonical specification of the second 500 bytes (byte offsets 500-999, inclusive)",
+        input: "bytes=500-700,601-999",
+        oracle: {begin: 500, end: 1000}
+    }
+];
+describe("range interpretation", function () {
+    tests.forEach(function (test) {
+        it("should interpret " + test.input, function () {
+            expect(Apps.interpretFirstRange(test.input, size)).toEqual(test.oracle);
+        });
+    });
+});

data/vendor/node_modules/traceur/node_modules/q-io/spec/http-apps/partial-range-spec.js ADDED Viewed

@@ -0,0 +1,186 @@
+require("../lib/jasmine-promise");
+var Http = require("../../http");
+var Apps = require("../../http-apps");
+var FS = require("../../fs");
+// http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35.1
+describe("HTTP Range", function () {
+    var fixture, app, serveAndTest;
+    describe("Byte Ranges" , function () {
+        beforeEach(function () {
+            fixture = FS.join(module.directory || __dirname, "fixtures", "01234.txt");
+            app = new Apps.Chain()
+                .use(Apps.Cap)
+                .use(function () {
+                    return Apps.File(fixture);
+                })
+                .end();
+            serveAndTest = function serveAndTest(rangeExp, expectedStatus) {
+                return Http.Server(app)
+                .listen(0)
+                .then(function (server) {
+                    var port = server.node.address().port;
+                    return Http.read({
+                        "url": "http://127.0.0.1:" + port + "/",
+                        "headers": {
+                            "range": rangeExp
+                        }
+                    }, function (response) {
+                        return response.status === expectedStatus;
+                    }).finally(server.stop);
+                })
+            }
+        });
+        // A byte range operation MAY specify a single range of bytes, or a set of ranges within a single entity.
+        //    ranges-specifier = byte-ranges-specifier
+        //    byte-ranges-specifier = bytes-unit "=" byte-range-set
+        //    byte-range-set  = 1#( byte-range-spec | suffix-byte-range-spec )
+        //    byte-range-spec = first-byte-pos "-" [last-byte-pos]
+        //    first-byte-pos  = 1*DIGIT
+        //    last-byte-pos   = 1*DIGIT
+        describe("byte range spec", function () {
+            // The first-byte-pos value in a byte-range-spec gives the byte-offset of the first byte in a range. The
+            // last-byte-pos value gives the byte-offset of the last byte in the range; that is, the byte positions
+            // specified are inclusive. Byte offsets start at zero.
+            it("positions are inclusive", function () {
+               return serveAndTest("bytes=0-2", 206)
+               .then(function (content) {
+                   expect(content.toString('utf-8')).toEqual('012');
+               });
+            });
+            it("last position is optional", function () {
+               return serveAndTest("bytes=0-", 206)
+               .then(function (content) {
+                   expect(content.toString('utf-8')).toEqual('01234.txt\n');
+               });
+            });
+            // TODO
+            xit("non contiguous ranges", function () {
+               return serveAndTest("bytes=0-2,4-5", 206)
+               .then(function (content) {
+                   expect(content.toString('utf-8')).toEqual('0124.');
+               });
+            });
+            // If the last-byte-pos value is present, it MUST be greater than
+            // or equal to the first-byte-pos in that byte-range-spec, or the
+            // byte- range-spec is syntactically invalid. The recipient of a
+            // byte-range- set that includes one or more syntactically invalid
+            // byte-range-spec values MUST ignore the header field that
+            // includes that byte-range- set.
+            describe("invalid syntax should be ignored", function () {
+                it("last positions must be greater than first", function () {
+                    return serveAndTest("bytes=4-3", 216)
+                    .then(function (content) {
+                        expect(false).toBe(true);
+                    }, function (error) {
+                        expect(error.response.status).toBe(416);
+                    })
+                });
+                it("if any part is invalid, all of it is invalid", function () {
+                    return serveAndTest("bytes=0-2,4-3", 216)
+                    .then(function (content) {
+                        expect(false).toBe(true);
+                    }, function (error) {
+                        expect(error.response.status).toBe(416);
+                    });
+                });
+            });
+            // If the last-byte-pos value is absent, or if the value is greater than or equal to the current length of
+            // the entity-body, last-byte-pos is taken to be equal to one less than the current length of the entity-
+            // body in bytes.
+            describe("last position should be truncated to the length of the content", function () {
+                it("single range", function () {
+                   return serveAndTest("bytes=0-10", 206)
+                   .then(function (content) {
+                       expect(content.toString('utf-8')).toEqual('01234.txt\n');
+                   });
+                });
+                // TODO
+                xit("multiple ranges", function () {
+                   return serveAndTest("bytes=0-2,1-10", 206)
+                   .then(function (content) {
+                       expect(content.toString('utf-8')).toEqual('0121234.txt\n');
+                   });
+                });
+            });
+        });
+        //By its choice of last-byte-pos, a client can limit the number of
+        //bytes retrieved without knowing the size of
+        // the entity.
+        //    suffix-byte-range-spec = "-" suffix-length
+        //    suffix-length = 1*DIGIT
+        describe("suffix byte range spec", function () {
+            it("can limit the number of bytes retrieved", function () {
+               return serveAndTest("bytes=-3", 206)
+               .then(function (content) {
+                   expect(content.toString('utf-8')).toEqual('0123');
+               });
+            });
+            // A suffix-byte-range-spec is used to specify the suffix of the
+            // entity-body, of a length given by the suffix-length value. (That
+            // is, this form specifies the last N bytes of an entity-body.) If
+            // the entity is shorter than the specified suffix-length, the
+            // entire entity-body is used.
+            it("last position should be truncated to the length", function () {
+               return serveAndTest("bytes=-20", 206)
+               .then(function (content) {
+                   expect(content.toString('utf-8')).toEqual('01234.txt\n');
+               });
+            });
+        });
+        // If a syntactically valid byte-range-set includes at least one byte-
+        // range-spec whose first-byte-pos is less than the current length of
+        // the entity-body, or at least one suffix-byte-range-spec with a non-
+        // zero suffix-length, then the byte-range-set is satisfiable.
+        // Otherwise, the byte-range-set is unsatisfiable.  If the
+        // byte-range-set is unsatisfiable, the server SHOULD return a response
+        // with a status of 416 (Requested range not satisfiable). Otherwise,
+        // the server SHOULD return a response with a status of 206 (Partial
+        // Content) containing the satisfiable ranges of the entity-body.
+        describe("satisfiability", function () {
+            it("should return 416 if a byte range spec is unsatisfiable", function () {
+               return serveAndTest("bytes=10-11", 416)
+               .then(function (content) {
+                   expect(true).toBeTruthy();
+               }).fail(function () {
+                   expect(false).toBeTruthy();
+               });
+            });
+            it("should return 416 if a suffix byte range spec is unsatisfiable", function () {
+               return serveAndTest("bytes=1-0", 206)
+               .then(function (content) {
+                   expect(true).toBeFalsy();
+               }).fail(function (error) {
+                   expect(error.response.status).toBe(416);
+               });
+            });
+            it("should return 416 if all byte range spec are unsatisfiable", function () {
+               return serveAndTest("bytes=10-11,-0", 416)
+               .then(function (content) {
+                   expect(true).toBeTruthy();
+               }).fail(function () {
+                   expect(false).toBeTruthy();
+               });
+            });
+            // TODO
+            xit("should return 200 if at least one byte range spec is satisfiable", function () {
+               return serveAndTest("bytes=10-11,0-2", 200)
+               .then(function (content) {
+                   expect(content.toString('utf-8')).toEqual('012');
+               });
+            });
+        });
+    });
+});

data/vendor/node_modules/traceur/node_modules/q-io/spec/http-apps/proxy-spec.js ADDED Viewed

@@ -0,0 +1,82 @@
+require("../lib/jasmine-promise");
+var Q = require("q");
+var Http = require("../../http");
+var Apps = require("../../http-apps");
+var FS = require("../../fs");
+describe("http proxy", function () {
+    it("should work", function () {
+        var requestProxy;
+        var responseProxy;
+        var requestActual;
+        var responseActual;
+        var app = Apps.Chain()
+        .use(Apps.Trap, function (response) {
+            responseActual = response;
+            return response;
+        })
+        .use(Apps.Tap, function (request) {
+            requestActual = request;
+        })
+        .use(function (next) {
+            return Apps.Branch({
+                "foo": Apps.Branch({
+                    "bar": new Apps.Chain()
+                        .use(Apps.Cap)
+                        .use(function () {
+                            return Apps.Content(["Hello, World!"])
+                        })
+                        .end()
+                })
+            })
+        })
+        .end();
+        var server1 = Http.Server(app);
+        return Q.when(server1.listen(0))
+        .then(function (server1) {
+            var port = server1.node.address().port;
+            var server2 = Http.Server(
+                Apps.Trap(
+                    Apps.Tap(
+                        Apps.ProxyTree("http://127.0.0.1:" + port + "/foo/"),
+                        function (request) {
+                            requestProxy = request;
+                        }
+                    ),
+                    function (response) {
+                        responseProxy = response;
+                        return response;
+                    }
+                )
+            );
+            return [server1, server2.listen(0)];
+        })
+        .spread(function (server1, server2) {
+            var port = server2.node.address().port;
+            return Http.read({
+                url: "http://127.0.0.1:" + port + "/bar",
+                charset: "utf-8"
+            })
+            .then(function (content) {
+                expect(content).toBe("Hello, World!");
+                expect(requestActual).toBeTruthy();
+                expect(responseActual).toBeTruthy();
+                expect(requestProxy).toBeTruthy();
+                expect(responseProxy).toBeTruthy();
+            })
+            .finally(server1.stop)
+            .finally(server2.stop)
+        })
+    });
+});