BVB Source Codes

parse-server Show ParseACL.spec.js Source code

Return Download parse-server: download ParseACL.spec.js Source code - Download parse-server Source code - Type:.js
  1. // This is a port of the test suite:
  2. // hungry/js/test/parse_acl_test.js
  3. var rest = require('../src/rest');
  4. var Config = require('../src/Config');
  5. var auth = require('../src/Auth');
  6.  
  7. describe('Parse.ACL', () => {
  8.   it("acl must be valid", (done) => {
  9.     var user = new Parse.User();
  10.     ok(!user.setACL("Ceci n'est pas un ACL.", {
  11.       error: function(user, error) {
  12.         equal(error.code, -1);
  13.         done();
  14.       }
  15.     }), "setACL should have returned false.");
  16.   });
  17.  
  18.   it("refresh object with acl", (done) => {
  19.     // Create an object owned by Alice.
  20.     var user = new Parse.User();
  21.     user.set("username", "alice");
  22.     user.set("password", "wonderland");
  23.     user.signUp(null, {
  24.       success: function() {
  25.         var object = new TestObject();
  26.         var acl = new Parse.ACL(user);
  27.         object.setACL(acl);
  28.         object.save(null, {
  29.           success: function() {
  30.             // Refreshing the object should succeed.
  31.             object.fetch({
  32.               success: function() {
  33.                 done();
  34.               }
  35.             });
  36.           }
  37.         });
  38.       }
  39.     });
  40.   });
  41.  
  42.   it("acl an object owned by one user and public get", (done) => {
  43.     // Create an object owned by Alice.
  44.     var user = new Parse.User();
  45.     user.set("username", "alice");
  46.     user.set("password", "wonderland");
  47.     user.signUp(null, {
  48.       success: function() {
  49.         var object = new TestObject();
  50.         var acl = new Parse.ACL(user);
  51.         object.setACL(acl);
  52.         object.save(null, {
  53.           success: function() {
  54.             equal(object.getACL().getReadAccess(user), true);
  55.             equal(object.getACL().getWriteAccess(user), true);
  56.             equal(object.getACL().getPublicReadAccess(), false);
  57.             equal(object.getACL().getPublicWriteAccess(), false);
  58.             ok(object.get("ACL"));
  59.             // Start making requests by the public, which should all fail.
  60.             Parse.User.logOut()
  61.             .then(() => {
  62.               // Get
  63.               var query = new Parse.Query(TestObject);
  64.               query.get(object.id, {
  65.                 success: function() {
  66.                   fail('Should not have retrieved the object.');
  67.                   done();
  68.                 },
  69.                 error: function(model, error) {
  70.                   equal(error.code, Parse.Error.OBJECT_NOT_FOUND);
  71.                   done();
  72.                 }
  73.               });
  74.             });
  75.           }
  76.         });
  77.       }
  78.     });
  79.   });
  80.  
  81.   it("acl an object owned by one user and public find", (done) => {
  82.     // Create an object owned by Alice.
  83.     var user = new Parse.User();
  84.     user.set("username", "alice");
  85.     user.set("password", "wonderland");
  86.     user.signUp(null, {
  87.       success: function() {
  88.         var object = new TestObject();
  89.         var acl = new Parse.ACL(user);
  90.         object.setACL(acl);
  91.         object.save(null, {
  92.           success: function() {
  93.             equal(object.getACL().getReadAccess(user), true);
  94.             equal(object.getACL().getWriteAccess(user), true);
  95.             equal(object.getACL().getPublicReadAccess(), false);
  96.             equal(object.getACL().getPublicWriteAccess(), false);
  97.             ok(object.get("ACL"));
  98.  
  99.             // Start making requests by the public, which should all fail.
  100.             Parse.User.logOut()
  101.             .then(() => {
  102.               // Find
  103.               var query = new Parse.Query(TestObject);
  104.               query.find({
  105.                 success: function(results) {
  106.                   equal(results.length, 0);
  107.                   done();
  108.                 }
  109.               });
  110.             });
  111.  
  112.           }
  113.         });
  114.       }
  115.     });
  116.   });
  117.  
  118.   it("acl an object owned by one user and public update", (done) => {
  119.     // Create an object owned by Alice.
  120.     var user = new Parse.User();
  121.     user.set("username", "alice");
  122.     user.set("password", "wonderland");
  123.     user.signUp(null, {
  124.       success: function() {
  125.         var object = new TestObject();
  126.         var acl = new Parse.ACL(user);
  127.         object.setACL(acl);
  128.         object.save(null, {
  129.           success: function() {
  130.             equal(object.getACL().getReadAccess(user), true);
  131.             equal(object.getACL().getWriteAccess(user), true);
  132.             equal(object.getACL().getPublicReadAccess(), false);
  133.             equal(object.getACL().getPublicWriteAccess(), false);
  134.             ok(object.get("ACL"));
  135.  
  136.             // Start making requests by the public, which should all fail.
  137.             Parse.User.logOut()
  138.             .then(() => {
  139.               // Update
  140.               object.set("foo", "bar");
  141.               object.save(null, {
  142.                 success: function() {
  143.                   fail('Should not have been able to update the object.');
  144.                   done();
  145.                 }, error: function(model, err) {
  146.                   equal(err.code, Parse.Error.OBJECT_NOT_FOUND);
  147.                   done();
  148.                 }
  149.               });
  150.             });
  151.           }
  152.         });
  153.       }
  154.     });
  155.   });
  156.  
  157.   it("acl an object owned by one user and public delete", (done) => {
  158.     // Create an object owned by Alice.
  159.     var user = new Parse.User();
  160.     user.set("username", "alice");
  161.     user.set("password", "wonderland");
  162.     user.signUp(null, {
  163.       success: function() {
  164.         var object = new TestObject();
  165.         var acl = new Parse.ACL(user);
  166.         object.setACL(acl);
  167.         object.save(null, {
  168.           success: function() {
  169.             equal(object.getACL().getReadAccess(user), true);
  170.             equal(object.getACL().getWriteAccess(user), true);
  171.             equal(object.getACL().getPublicReadAccess(), false);
  172.             equal(object.getACL().getPublicWriteAccess(), false);
  173.             ok(object.get("ACL"));
  174.  
  175.             // Start making requests by the public, which should all fail.
  176.             Parse.User.logOut()
  177.             .then(() => object.destroy())
  178.             .then(() => {
  179.               fail('destroy should fail');
  180.               done();
  181.             }, error => {
  182.               expect(error.code).toEqual(Parse.Error.OBJECT_NOT_FOUND);
  183.               done();
  184.             });
  185.           }
  186.         });
  187.       }
  188.     });
  189.   });
  190.  
  191.   it("acl an object owned by one user and logged in get", (done) => {
  192.     // Create an object owned by Alice.
  193.     var user = new Parse.User();
  194.     user.set("username", "alice");
  195.     user.set("password", "wonderland");
  196.     user.signUp(null, {
  197.       success: function() {
  198.         var object = new TestObject();
  199.         var acl = new Parse.ACL(user);
  200.         object.setACL(acl);
  201.         object.save(null, {
  202.           success: function() {
  203.             equal(object.getACL().getReadAccess(user), true);
  204.             equal(object.getACL().getWriteAccess(user), true);
  205.             equal(object.getACL().getPublicReadAccess(), false);
  206.             equal(object.getACL().getPublicWriteAccess(), false);
  207.             ok(object.get("ACL"));
  208.  
  209.             Parse.User.logOut()
  210.             .then(() => {
  211.               Parse.User.logIn("alice", "wonderland", {
  212.                 success: function() {
  213.                   // Get
  214.                   var query = new Parse.Query(TestObject);
  215.                   query.get(object.id, {
  216.                     success: function(result) {
  217.                       ok(result);
  218.                       equal(result.id, object.id);
  219.                       equal(result.getACL().getReadAccess(user), true);
  220.                       equal(result.getACL().getWriteAccess(user), true);
  221.                       equal(result.getACL().getPublicReadAccess(), false);
  222.                       equal(result.getACL().getPublicWriteAccess(), false);
  223.                       ok(object.get("ACL"));
  224.                       done();
  225.                     }
  226.                   });
  227.                 }
  228.               });
  229.             });
  230.           }
  231.         });
  232.       }
  233.     });
  234.   });
  235.  
  236.   it("acl an object owned by one user and logged in find", (done) => {
  237.     // Create an object owned by Alice.
  238.     var user = new Parse.User();
  239.     user.set("username", "alice");
  240.     user.set("password", "wonderland");
  241.     user.signUp(null, {
  242.       success: function() {
  243.         var object = new TestObject();
  244.         var acl = new Parse.ACL(user);
  245.         object.setACL(acl);
  246.         object.save(null, {
  247.           success: function() {
  248.             equal(object.getACL().getReadAccess(user), true);
  249.             equal(object.getACL().getWriteAccess(user), true);
  250.             equal(object.getACL().getPublicReadAccess(), false);
  251.             equal(object.getACL().getPublicWriteAccess(), false);
  252.             ok(object.get("ACL"));
  253.  
  254.             Parse.User.logOut()
  255.             .then(() => {
  256.               Parse.User.logIn("alice", "wonderland", {
  257.                 success: function() {
  258.                   // Find
  259.                   var query = new Parse.Query(TestObject);
  260.                   query.find({
  261.                     success: function(results) {
  262.                       equal(results.length, 1);
  263.                       var result = results[0];
  264.                       ok(result);
  265.                       if (!result) {
  266.                         return fail();
  267.                       }
  268.                       equal(result.id, object.id);
  269.                       equal(result.getACL().getReadAccess(user), true);
  270.                       equal(result.getACL().getWriteAccess(user), true);
  271.                       equal(result.getACL().getPublicReadAccess(), false);
  272.                       equal(result.getACL().getPublicWriteAccess(), false);
  273.                       ok(object.get("ACL"));
  274.                       done();
  275.                     }
  276.                   });
  277.                 }
  278.               });
  279.             });
  280.           }
  281.         });
  282.       }
  283.     });
  284.   });
  285.  
  286.   it("acl an object owned by one user and logged in update", (done) => {
  287.     // Create an object owned by Alice.
  288.     var user = new Parse.User();
  289.     user.set("username", "alice");
  290.     user.set("password", "wonderland");
  291.     user.signUp(null, {
  292.       success: function() {
  293.         var object = new TestObject();
  294.         var acl = new Parse.ACL(user);
  295.         object.setACL(acl);
  296.         object.save(null, {
  297.           success: function() {
  298.             equal(object.getACL().getReadAccess(user), true);
  299.             equal(object.getACL().getWriteAccess(user), true);
  300.             equal(object.getACL().getPublicReadAccess(), false);
  301.             equal(object.getACL().getPublicWriteAccess(), false);
  302.             ok(object.get("ACL"));
  303.  
  304.             Parse.User.logOut()
  305.             .then(() => {
  306.               Parse.User.logIn("alice", "wonderland", {
  307.                 success: function() {
  308.                   // Update
  309.                   object.set("foo", "bar");
  310.                   object.save(null, {
  311.                     success: function() {
  312.                       done();
  313.                     }
  314.                   });
  315.                 }
  316.               });
  317.             });
  318.           }
  319.         });
  320.       }
  321.     });
  322.   });
  323.  
  324.   it("acl an object owned by one user and logged in delete", (done) => {
  325.     // Create an object owned by Alice.
  326.     var user = new Parse.User();
  327.     user.set("username", "alice");
  328.     user.set("password", "wonderland");
  329.     user.signUp(null, {
  330.       success: function() {
  331.         var object = new TestObject();
  332.         var acl = new Parse.ACL(user);
  333.         object.setACL(acl);
  334.         object.save(null, {
  335.           success: function() {
  336.             equal(object.getACL().getReadAccess(user), true);
  337.             equal(object.getACL().getWriteAccess(user), true);
  338.             equal(object.getACL().getPublicReadAccess(), false);
  339.             equal(object.getACL().getPublicWriteAccess(), false);
  340.             ok(object.get("ACL"));
  341.  
  342.             Parse.User.logOut()
  343.             .then(() => {
  344.               Parse.User.logIn("alice", "wonderland", {
  345.                 success: function() {
  346.                   // Delete
  347.                   object.destroy({
  348.                     success: function() {
  349.                       done();
  350.                     }
  351.                   });
  352.                 }
  353.               });
  354.             });
  355.           }
  356.         });
  357.       }
  358.     });
  359.   });
  360.  
  361.   it("acl making an object publicly readable and public get", (done) => {
  362.     // Create an object owned by Alice.
  363.     var user = new Parse.User();
  364.     user.set("username", "alice");
  365.     user.set("password", "wonderland");
  366.     user.signUp(null, {
  367.       success: function() {
  368.         var object = new TestObject();
  369.         var acl = new Parse.ACL(user);
  370.         object.setACL(acl);
  371.         object.save(null, {
  372.           success: function() {
  373.             equal(object.getACL().getReadAccess(user), true);
  374.             equal(object.getACL().getWriteAccess(user), true);
  375.             equal(object.getACL().getPublicReadAccess(), false);
  376.             equal(object.getACL().getPublicWriteAccess(), false);
  377.             ok(object.get("ACL"));
  378.  
  379.             // Now make it public.
  380.             object.getACL().setPublicReadAccess(true);
  381.             object.save(null, {
  382.               success: function() {
  383.                 equal(object.getACL().getReadAccess(user), true);
  384.                 equal(object.getACL().getWriteAccess(user), true);
  385.                 equal(object.getACL().getPublicReadAccess(), true);
  386.                 equal(object.getACL().getPublicWriteAccess(), false);
  387.                 ok(object.get("ACL"));
  388.  
  389.                 Parse.User.logOut()
  390.                 .then(() => {
  391.                   // Get
  392.                   var query = new Parse.Query(TestObject);
  393.                   query.get(object.id, {
  394.                     success: function(result) {
  395.                       ok(result);
  396.                       equal(result.id, object.id);
  397.                       done();
  398.                     }
  399.                   });
  400.                 });
  401.               }
  402.             });
  403.           }
  404.         });
  405.       }
  406.     });
  407.   });
  408.  
  409.   it("acl making an object publicly readable and public find", (done) => {
  410.     // Create an object owned by Alice.
  411.     var user = new Parse.User();
  412.     user.set("username", "alice");
  413.     user.set("password", "wonderland");
  414.     user.signUp(null, {
  415.       success: function() {
  416.         var object = new TestObject();
  417.         var acl = new Parse.ACL(user);
  418.         object.setACL(acl);
  419.         object.save(null, {
  420.           success: function() {
  421.             equal(object.getACL().getReadAccess(user), true);
  422.             equal(object.getACL().getWriteAccess(user), true);
  423.             equal(object.getACL().getPublicReadAccess(), false);
  424.             equal(object.getACL().getPublicWriteAccess(), false);
  425.             ok(object.get("ACL"));
  426.  
  427.             // Now make it public.
  428.             object.getACL().setPublicReadAccess(true);
  429.             object.save(null, {
  430.               success: function() {
  431.                 equal(object.getACL().getReadAccess(user), true);
  432.                 equal(object.getACL().getWriteAccess(user), true);
  433.                 equal(object.getACL().getPublicReadAccess(), true);
  434.                 equal(object.getACL().getPublicWriteAccess(), false);
  435.                 ok(object.get("ACL"));
  436.  
  437.                 Parse.User.logOut()
  438.                 .then(() => {
  439.                   // Find
  440.                   var query = new Parse.Query(TestObject);
  441.                   query.find({
  442.                     success: function(results) {
  443.                       equal(results.length, 1);
  444.                       var result = results[0];
  445.                       ok(result);
  446.                       equal(result.id, object.id);
  447.                       done();
  448.                     }
  449.                   });
  450.                 });
  451.               }
  452.             });
  453.           }
  454.         });
  455.       }
  456.     });
  457.   });
  458.  
  459.   it("acl making an object publicly readable and public update", (done) => {
  460.     // Create an object owned by Alice.
  461.     var user = new Parse.User();
  462.     user.set("username", "alice");
  463.     user.set("password", "wonderland");
  464.     user.signUp(null, {
  465.       success: function() {
  466.         var object = new TestObject();
  467.         var acl = new Parse.ACL(user);
  468.         object.setACL(acl);
  469.         object.save(null, {
  470.           success: function() {
  471.             equal(object.getACL().getReadAccess(user), true);
  472.             equal(object.getACL().getWriteAccess(user), true);
  473.             equal(object.getACL().getPublicReadAccess(), false);
  474.             equal(object.getACL().getPublicWriteAccess(), false);
  475.             ok(object.get("ACL"));
  476.  
  477.             // Now make it public.
  478.             object.getACL().setPublicReadAccess(true);
  479.             object.save(null, {
  480.               success: function() {
  481.                 equal(object.getACL().getReadAccess(user), true);
  482.                 equal(object.getACL().getWriteAccess(user), true);
  483.                 equal(object.getACL().getPublicReadAccess(), true);
  484.                 equal(object.getACL().getPublicWriteAccess(), false);
  485.                 ok(object.get("ACL"));
  486.  
  487.                 Parse.User.logOut()
  488.                 .then(() => {
  489.                   // Update
  490.                   object.set("foo", "bar");
  491.                   object.save().then(() => {
  492.                     fail('the save should fail');
  493.                   }, error => {
  494.                     expect(error.code).toEqual(Parse.Error.OBJECT_NOT_FOUND);
  495.                     done();
  496.                   });
  497.                 });
  498.               }
  499.             });
  500.           }
  501.         });
  502.       }
  503.     });
  504.   });
  505.  
  506.   it("acl making an object publicly readable and public delete", (done) => {
  507.     // Create an object owned by Alice.
  508.     var user = new Parse.User();
  509.     user.set("username", "alice");
  510.     user.set("password", "wonderland");
  511.     user.signUp(null, {
  512.       success: function() {
  513.         var object = new TestObject();
  514.         var acl = new Parse.ACL(user);
  515.         object.setACL(acl);
  516.         object.save(null, {
  517.           success: function() {
  518.             equal(object.getACL().getReadAccess(user), true);
  519.             equal(object.getACL().getWriteAccess(user), true);
  520.             equal(object.getACL().getPublicReadAccess(), false);
  521.             equal(object.getACL().getPublicWriteAccess(), false);
  522.             ok(object.get("ACL"));
  523.  
  524.             // Now make it public.
  525.             object.getACL().setPublicReadAccess(true);
  526.             object.save(null, {
  527.               success: function() {
  528.                 equal(object.getACL().getReadAccess(user), true);
  529.                 equal(object.getACL().getWriteAccess(user), true);
  530.                 equal(object.getACL().getPublicReadAccess(), true);
  531.                 equal(object.getACL().getPublicWriteAccess(), false);
  532.                 ok(object.get("ACL"));
  533.  
  534.                 Parse.User.logOut()
  535.                 .then(() => object.destroy())
  536.                 .then(() => {
  537.                   fail('expected failure');
  538.                 }, error => {
  539.                   expect(error.code).toEqual(Parse.Error.OBJECT_NOT_FOUND);
  540.                   done();
  541.                 });
  542.               }
  543.             });
  544.           }
  545.         });
  546.       }
  547.     });
  548.   });
  549.  
  550.   it("acl making an object publicly writable and public get", (done) => {
  551.     // Create an object owned by Alice.
  552.     var user = new Parse.User();
  553.     user.set("username", "alice");
  554.     user.set("password", "wonderland");
  555.     user.signUp(null, {
  556.       success: function() {
  557.         var object = new TestObject();
  558.         var acl = new Parse.ACL(user);
  559.         object.setACL(acl);
  560.         object.save(null, {
  561.           success: function() {
  562.             equal(object.getACL().getReadAccess(user), true);
  563.             equal(object.getACL().getWriteAccess(user), true);
  564.             equal(object.getACL().getPublicReadAccess(), false);
  565.             equal(object.getACL().getPublicWriteAccess(), false);
  566.             ok(object.get("ACL"));
  567.  
  568.             // Now make it public.
  569.             object.getACL().setPublicWriteAccess(true);
  570.             object.save(null, {
  571.               success: function() {
  572.                 equal(object.getACL().getReadAccess(user), true);
  573.                 equal(object.getACL().getWriteAccess(user), true);
  574.                 equal(object.getACL().getPublicReadAccess(), false);
  575.                 equal(object.getACL().getPublicWriteAccess(), true);
  576.                 ok(object.get("ACL"));
  577.  
  578.                 Parse.User.logOut()
  579.                 .then(() => {
  580.                   // Get
  581.                   var query = new Parse.Query(TestObject);
  582.                   query.get(object.id, {
  583.                     error: function(model, error) {
  584.                       equal(error.code, Parse.Error.OBJECT_NOT_FOUND);
  585.                       done();
  586.                     }
  587.                   });
  588.                 });
  589.               }
  590.             });
  591.           }
  592.         });
  593.       }
  594.     });
  595.   });
  596.  
  597.   it("acl making an object publicly writable and public find", (done) => {
  598.     // Create an object owned by Alice.
  599.     var user = new Parse.User();
  600.     user.set("username", "alice");
  601.     user.set("password", "wonderland");
  602.     user.signUp(null, {
  603.       success: function() {
  604.         var object = new TestObject();
  605.         var acl = new Parse.ACL(user);
  606.         object.setACL(acl);
  607.         object.save(null, {
  608.           success: function() {
  609.             equal(object.getACL().getReadAccess(user), true);
  610.             equal(object.getACL().getWriteAccess(user), true);
  611.             equal(object.getACL().getPublicReadAccess(), false);
  612.             equal(object.getACL().getPublicWriteAccess(), false);
  613.             ok(object.get("ACL"));
  614.  
  615.             // Now make it public.
  616.             object.getACL().setPublicWriteAccess(true);
  617.             object.save(null, {
  618.               success: function() {
  619.                 equal(object.getACL().getReadAccess(user), true);
  620.                 equal(object.getACL().getWriteAccess(user), true);
  621.                 equal(object.getACL().getPublicReadAccess(), false);
  622.                 equal(object.getACL().getPublicWriteAccess(), true);
  623.                 ok(object.get("ACL"));
  624.  
  625.                 Parse.User.logOut()
  626.                 .then(() => {
  627.                   // Find
  628.                   var query = new Parse.Query(TestObject);
  629.                   query.find({
  630.                     success: function(results) {
  631.                       equal(results.length, 0);
  632.                       done();
  633.                     }
  634.                   });
  635.                 });
  636.               }
  637.             });
  638.           }
  639.         });
  640.       }
  641.     });
  642.   });
  643.  
  644.   it("acl making an object publicly writable and public update", (done) => {
  645.     // Create an object owned by Alice.
  646.     var user = new Parse.User();
  647.     user.set("username", "alice");
  648.     user.set("password", "wonderland");
  649.     user.signUp(null, {
  650.       success: function() {
  651.         var object = new TestObject();
  652.         var acl = new Parse.ACL(user);
  653.         object.setACL(acl);
  654.         object.save(null, {
  655.           success: function() {
  656.             equal(object.getACL().getReadAccess(user), true);
  657.             equal(object.getACL().getWriteAccess(user), true);
  658.             equal(object.getACL().getPublicReadAccess(), false);
  659.             equal(object.getACL().getPublicWriteAccess(), false);
  660.             ok(object.get("ACL"));
  661.  
  662.             // Now make it public.
  663.             object.getACL().setPublicWriteAccess(true);
  664.             object.save(null, {
  665.               success: function() {
  666.                 equal(object.getACL().getReadAccess(user), true);
  667.                 equal(object.getACL().getWriteAccess(user), true);
  668.                 equal(object.getACL().getPublicReadAccess(), false);
  669.                 equal(object.getACL().getPublicWriteAccess(), true);
  670.                 ok(object.get("ACL"));
  671.  
  672.                 Parse.User.logOut()
  673.                 .then(() => {
  674.                   // Update
  675.                   object.set("foo", "bar");
  676.                   object.save(null, {
  677.                     success: function() {
  678.                       done();
  679.                     }
  680.                   });
  681.                 });
  682.               }
  683.             });
  684.           }
  685.         });
  686.       }
  687.     });
  688.   });
  689.  
  690.   it("acl making an object publicly writable and public delete", (done) => {
  691.     // Create an object owned by Alice.
  692.     var user = new Parse.User();
  693.     user.set("username", "alice");
  694.     user.set("password", "wonderland");
  695.     user.signUp(null, {
  696.       success: function() {
  697.         var object = new TestObject();
  698.         var acl = new Parse.ACL(user);
  699.         object.setACL(acl);
  700.         object.save(null, {
  701.           success: function() {
  702.             equal(object.getACL().getReadAccess(user), true);
  703.             equal(object.getACL().getWriteAccess(user), true);
  704.             equal(object.getACL().getPublicReadAccess(), false);
  705.             equal(object.getACL().getPublicWriteAccess(), false);
  706.             ok(object.get("ACL"));
  707.  
  708.             // Now make it public.
  709.             object.getACL().setPublicWriteAccess(true);
  710.             object.save(null, {
  711.               success: function() {
  712.                 equal(object.getACL().getReadAccess(user), true);
  713.                 equal(object.getACL().getWriteAccess(user), true);
  714.                 equal(object.getACL().getPublicReadAccess(), false);
  715.                 equal(object.getACL().getPublicWriteAccess(), true);
  716.                 ok(object.get("ACL"));
  717.  
  718.                 Parse.User.logOut()
  719.                 .then(() => {
  720.                   // Delete
  721.                   object.destroy({
  722.                     success: function() {
  723.                       done();
  724.                     }
  725.                   });
  726.                 });
  727.               }
  728.             });
  729.           }
  730.         });
  731.       }
  732.     });
  733.   });
  734.  
  735.   it("acl making an object privately writable (#3194)", (done) => {
  736.     // Create an object owned by Alice.
  737.     var object;
  738.     var user2;
  739.     var user = new Parse.User();
  740.     user.set("username", "alice");
  741.     user.set("password", "wonderland");
  742.     user.signUp().then(() => {
  743.       object = new TestObject();
  744.       var acl = new Parse.ACL(user);
  745.       acl.setPublicWriteAccess(false);
  746.       acl.setPublicReadAccess(true);
  747.       object.setACL(acl);
  748.       return object.save().then(() => {
  749.         return Parse.User.logOut();
  750.       })
  751.     }).then(() => {
  752.       user2 = new Parse.User();
  753.       user2.set("username", "bob");
  754.       user2.set("password", "burger");
  755.       return user2.signUp();
  756.     }).then(() => {
  757.       return object.destroy({sessionToken: user2.getSessionToken() });
  758.     }).then(() => {
  759.       fail('should not be able to destroy the object');
  760.       done();
  761.     }, (err) => {
  762.       expect(err).not.toBeUndefined();
  763.       done();
  764.     });
  765.   });
  766.  
  767.   it("acl sharing with another user and get", (done) => {
  768.     // Sign in as Bob.
  769.     Parse.User.signUp("bob", "pass", null, {
  770.       success: function(bob) {
  771.         Parse.User.logOut()
  772.         .then(() => {
  773.           // Sign in as Alice.
  774.           Parse.User.signUp("alice", "wonderland", null, {
  775.             success: function(alice) {
  776.               // Create an object shared by Bob and Alice.
  777.               var object = new TestObject();
  778.               var acl = new Parse.ACL(alice);
  779.               acl.setWriteAccess(bob, true);
  780.               acl.setReadAccess(bob, true);
  781.               object.setACL(acl);
  782.               object.save(null, {
  783.                 success: function() {
  784.                   equal(object.getACL().getReadAccess(alice), true);
  785.                   equal(object.getACL().getWriteAccess(alice), true);
  786.                   equal(object.getACL().getReadAccess(bob), true);
  787.                   equal(object.getACL().getWriteAccess(bob), true);
  788.                   equal(object.getACL().getPublicReadAccess(), false);
  789.                   equal(object.getACL().getPublicWriteAccess(), false);
  790.  
  791.                   // Sign in as Bob again.
  792.                   Parse.User.logIn("bob", "pass", {
  793.                     success: function() {
  794.                       var query = new Parse.Query(TestObject);
  795.                       query.get(object.id, {
  796.                         success: function(result) {
  797.                           ok(result);
  798.                           equal(result.id, object.id);
  799.                           done();
  800.                         }
  801.                       });
  802.                     }
  803.                   });
  804.                 }
  805.               });
  806.             }
  807.           });
  808.         });
  809.       }
  810.     });
  811.   });
  812.  
  813.   it("acl sharing with another user and find", (done) => {
  814.     // Sign in as Bob.
  815.     Parse.User.signUp("bob", "pass", null, {
  816.       success: function(bob) {
  817.         Parse.User.logOut()
  818.         .then(() => {
  819.           // Sign in as Alice.
  820.           Parse.User.signUp("alice", "wonderland", null, {
  821.             success: function(alice) {
  822.               // Create an object shared by Bob and Alice.
  823.               var object = new TestObject();
  824.               var acl = new Parse.ACL(alice);
  825.               acl.setWriteAccess(bob, true);
  826.               acl.setReadAccess(bob, true);
  827.               object.setACL(acl);
  828.               object.save(null, {
  829.                 success: function() {
  830.                   equal(object.getACL().getReadAccess(alice), true);
  831.                   equal(object.getACL().getWriteAccess(alice), true);
  832.                   equal(object.getACL().getReadAccess(bob), true);
  833.                   equal(object.getACL().getWriteAccess(bob), true);
  834.                   equal(object.getACL().getPublicReadAccess(), false);
  835.                   equal(object.getACL().getPublicWriteAccess(), false);
  836.  
  837.                   // Sign in as Bob again.
  838.                   Parse.User.logIn("bob", "pass", {
  839.                     success: function() {
  840.                       var query = new Parse.Query(TestObject);
  841.                       query.find({
  842.                         success: function(results) {
  843.                           equal(results.length, 1);
  844.                           var result = results[0];
  845.                           ok(result);
  846.                           if (!result) {
  847.                             fail("should have result");
  848.                           } else {
  849.                             equal(result.id, object.id);
  850.                           }
  851.                           done();
  852.                         }
  853.                       });
  854.                     }
  855.                   });
  856.                 }
  857.               });
  858.             }
  859.           });
  860.         });
  861.       }
  862.     });
  863.   });
  864.  
  865.   it("acl sharing with another user and update", (done) => {
  866.     // Sign in as Bob.
  867.     Parse.User.signUp("bob", "pass", null, {
  868.       success: function(bob) {
  869.         Parse.User.logOut()
  870.         .then(() => {
  871.           // Sign in as Alice.
  872.           Parse.User.signUp("alice", "wonderland", null, {
  873.             success: function(alice) {
  874.               // Create an object shared by Bob and Alice.
  875.               var object = new TestObject();
  876.               var acl = new Parse.ACL(alice);
  877.               acl.setWriteAccess(bob, true);
  878.               acl.setReadAccess(bob, true);
  879.               object.setACL(acl);
  880.               object.save(null, {
  881.                 success: function() {
  882.                   equal(object.getACL().getReadAccess(alice), true);
  883.                   equal(object.getACL().getWriteAccess(alice), true);
  884.                   equal(object.getACL().getReadAccess(bob), true);
  885.                   equal(object.getACL().getWriteAccess(bob), true);
  886.                   equal(object.getACL().getPublicReadAccess(), false);
  887.                   equal(object.getACL().getPublicWriteAccess(), false);
  888.  
  889.                   // Sign in as Bob again.
  890.                   Parse.User.logIn("bob", "pass", {
  891.                     success: function() {
  892.                       object.set("foo", "bar");
  893.                       object.save(null, {
  894.                         success: function() {
  895.                           done();
  896.                         }
  897.                       });
  898.                     }
  899.                   });
  900.                 }
  901.               });
  902.             }
  903.           });
  904.         });
  905.       }
  906.     });
  907.   });
  908.  
  909.   it("acl sharing with another user and delete", (done) => {
  910.     // Sign in as Bob.
  911.     Parse.User.signUp("bob", "pass", null, {
  912.       success: function(bob) {
  913.         Parse.User.logOut()
  914.         .then(() => {
  915.           // Sign in as Alice.
  916.           Parse.User.signUp("alice", "wonderland", null, {
  917.             success: function(alice) {
  918.               // Create an object shared by Bob and Alice.
  919.               var object = new TestObject();
  920.               var acl = new Parse.ACL(alice);
  921.               acl.setWriteAccess(bob, true);
  922.               acl.setReadAccess(bob, true);
  923.               object.setACL(acl);
  924.               object.save(null, {
  925.                 success: function() {
  926.                   equal(object.getACL().getReadAccess(alice), true);
  927.                   equal(object.getACL().getWriteAccess(alice), true);
  928.                   equal(object.getACL().getReadAccess(bob), true);
  929.                   equal(object.getACL().getWriteAccess(bob), true);
  930.                   equal(object.getACL().getPublicReadAccess(), false);
  931.                   equal(object.getACL().getPublicWriteAccess(), false);
  932.  
  933.                   // Sign in as Bob again.
  934.                   Parse.User.logIn("bob", "pass", {
  935.                     success: function() {
  936.                       object.set("foo", "bar");
  937.                       object.destroy({
  938.                         success: function() {
  939.                           done();
  940.                         }
  941.                       });
  942.                     }
  943.                   });
  944.                 }
  945.               });
  946.             }
  947.           });
  948.         });
  949.       }
  950.     });
  951.   });
  952.  
  953.   it("acl sharing with another user and public get", (done) => {
  954.     // Sign in as Bob.
  955.     Parse.User.signUp("bob", "pass", null, {
  956.       success: function(bob) {
  957.         Parse.User.logOut()
  958.         .then(() => {
  959.           // Sign in as Alice.
  960.           Parse.User.signUp("alice", "wonderland", null, {
  961.             success: function(alice) {
  962.               // Create an object shared by Bob and Alice.
  963.               var object = new TestObject();
  964.               var acl = new Parse.ACL(alice);
  965.               acl.setWriteAccess(bob, true);
  966.               acl.setReadAccess(bob, true);
  967.               object.setACL(acl);
  968.               object.save(null, {
  969.                 success: function() {
  970.                   equal(object.getACL().getReadAccess(alice), true);
  971.                   equal(object.getACL().getWriteAccess(alice), true);
  972.                   equal(object.getACL().getReadAccess(bob), true);
  973.                   equal(object.getACL().getWriteAccess(bob), true);
  974.                   equal(object.getACL().getPublicReadAccess(), false);
  975.                   equal(object.getACL().getPublicWriteAccess(), false);
  976.  
  977.                   // Start making requests by the public.
  978.                   Parse.User.logOut()
  979.                   .then(() => {
  980.                     var query = new Parse.Query(TestObject);
  981.                     query.get(object.id).then((result) => {
  982.                       fail(result);
  983.                     }, (error) => {
  984.                       expect(error.code).toEqual(Parse.Error.OBJECT_NOT_FOUND);
  985.                       done();
  986.                     });
  987.                   });
  988.                 }
  989.               });
  990.             }
  991.           });
  992.         });
  993.       }
  994.     });
  995.   });
  996.  
  997.   it("acl sharing with another user and public find", (done) => {
  998.     // Sign in as Bob.
  999.     Parse.User.signUp("bob", "pass", null, {
  1000.       success: function(bob) {
  1001.         Parse.User.logOut()
  1002.         .then(() => {
  1003.           // Sign in as Alice.
  1004.           Parse.User.signUp("alice", "wonderland", null, {
  1005.             success: function(alice) {
  1006.               // Create an object shared by Bob and Alice.
  1007.               var object = new TestObject();
  1008.               var acl = new Parse.ACL(alice);
  1009.               acl.setWriteAccess(bob, true);
  1010.               acl.setReadAccess(bob, true);
  1011.               object.setACL(acl);
  1012.               object.save(null, {
  1013.                 success: function() {
  1014.                   equal(object.getACL().getReadAccess(alice), true);
  1015.                   equal(object.getACL().getWriteAccess(alice), true);
  1016.                   equal(object.getACL().getReadAccess(bob), true);
  1017.                   equal(object.getACL().getWriteAccess(bob), true);
  1018.                   equal(object.getACL().getPublicReadAccess(), false);
  1019.                   equal(object.getACL().getPublicWriteAccess(), false);
  1020.  
  1021.                   // Start making requests by the public.
  1022.                   Parse.User.logOut()
  1023.                   .then(() => {
  1024.                     var query = new Parse.Query(TestObject);
  1025.                     query.find({
  1026.                       success: function(results) {
  1027.                         equal(results.length, 0);
  1028.                         done();
  1029.                       }
  1030.                     });
  1031.                   });
  1032.                 }
  1033.               });
  1034.             }
  1035.           });
  1036.         });
  1037.       }
  1038.     });
  1039.   });
  1040.  
  1041.   it("acl sharing with another user and public update", (done) => {
  1042.     // Sign in as Bob.
  1043.     Parse.User.signUp("bob", "pass", null, {
  1044.       success: function(bob) {
  1045.         Parse.User.logOut()
  1046.         .then(() => {
  1047.           // Sign in as Alice.
  1048.           Parse.User.signUp("alice", "wonderland", null, {
  1049.             success: function(alice) {
  1050.               // Create an object shared by Bob and Alice.
  1051.               var object = new TestObject();
  1052.               var acl = new Parse.ACL(alice);
  1053.               acl.setWriteAccess(bob, true);
  1054.               acl.setReadAccess(bob, true);
  1055.               object.setACL(acl);
  1056.               object.save(null, {
  1057.                 success: function() {
  1058.                   equal(object.getACL().getReadAccess(alice), true);
  1059.                   equal(object.getACL().getWriteAccess(alice), true);
  1060.                   equal(object.getACL().getReadAccess(bob), true);
  1061.                   equal(object.getACL().getWriteAccess(bob), true);
  1062.                   equal(object.getACL().getPublicReadAccess(), false);
  1063.                   equal(object.getACL().getPublicWriteAccess(), false);
  1064.  
  1065.                   // Start making requests by the public.
  1066.                   Parse.User.logOut()
  1067.                   .then(() => {
  1068.                     object.set("foo", "bar");
  1069.                     object.save().then(() => {
  1070.                       fail('expected failure');
  1071.                     }, (error) => {
  1072.                       expect(error.code).toEqual(Parse.Error.OBJECT_NOT_FOUND);
  1073.                       done();
  1074.                     });
  1075.                   });
  1076.                 }
  1077.               });
  1078.             }
  1079.           });
  1080.         });
  1081.       }
  1082.     });
  1083.   });
  1084.  
  1085.   it("acl sharing with another user and public delete", (done) => {
  1086.     // Sign in as Bob.
  1087.     Parse.User.signUp("bob", "pass", null, {
  1088.       success: function(bob) {
  1089.         Parse.User.logOut()
  1090.         .then(() => {
  1091.           // Sign in as Alice.
  1092.           Parse.User.signUp("alice", "wonderland", null, {
  1093.             success: function(alice) {
  1094.               // Create an object shared by Bob and Alice.
  1095.               var object = new TestObject();
  1096.               var acl = new Parse.ACL(alice);
  1097.               acl.setWriteAccess(bob, true);
  1098.               acl.setReadAccess(bob, true);
  1099.               object.setACL(acl);
  1100.               object.save(null, {
  1101.                 success: function() {
  1102.                   equal(object.getACL().getReadAccess(alice), true);
  1103.                   equal(object.getACL().getWriteAccess(alice), true);
  1104.                   equal(object.getACL().getReadAccess(bob), true);
  1105.                   equal(object.getACL().getWriteAccess(bob), true);
  1106.                   equal(object.getACL().getPublicReadAccess(), false);
  1107.                   equal(object.getACL().getPublicWriteAccess(), false);
  1108.  
  1109.                   // Start making requests by the public.
  1110.                   Parse.User.logOut()
  1111.                   .then(() => object.destroy())
  1112.                   .then(() => {
  1113.                     fail('expected failure');
  1114.                   }, (error) => {
  1115.                     expect(error.code).toEqual(Parse.Error.OBJECT_NOT_FOUND);
  1116.                     done();
  1117.                   });
  1118.                 }
  1119.               });
  1120.             }
  1121.           });
  1122.         });
  1123.       }
  1124.     });
  1125.   });
  1126.  
  1127.   it("acl saveAll with permissions", (done) => {
  1128.     Parse.User.signUp("alice", "wonderland", null, {
  1129.       success: function(alice) {
  1130.         var acl = new Parse.ACL(alice);
  1131.  
  1132.         var object1 = new TestObject();
  1133.         var object2 = new TestObject();
  1134.         object1.setACL(acl);
  1135.         object2.setACL(acl);
  1136.         Parse.Object.saveAll([object1, object2], {
  1137.           success: function() {
  1138.             equal(object1.getACL().getReadAccess(alice), true);
  1139.             equal(object1.getACL().getWriteAccess(alice), true);
  1140.             equal(object1.getACL().getPublicReadAccess(), false);
  1141.             equal(object1.getACL().getPublicWriteAccess(), false);
  1142.             equal(object2.getACL().getReadAccess(alice), true);
  1143.             equal(object2.getACL().getWriteAccess(alice), true);
  1144.             equal(object2.getACL().getPublicReadAccess(), false);
  1145.             equal(object2.getACL().getPublicWriteAccess(), false);
  1146.  
  1147.             // Save all the objects after updating them.
  1148.             object1.set("foo", "bar");
  1149.             object2.set("foo", "bar");
  1150.             Parse.Object.saveAll([object1, object2], {
  1151.               success: function() {
  1152.                 var query = new Parse.Query(TestObject);
  1153.                 query.equalTo("foo", "bar");
  1154.                 query.find({
  1155.                   success: function(results) {
  1156.                     equal(results.length, 2);
  1157.                     done();
  1158.                   }
  1159.                 });
  1160.               }
  1161.             });
  1162.           }
  1163.         });
  1164.       }
  1165.     });
  1166.   });
  1167.  
  1168.   it("empty acl works", (done) => {
  1169.     Parse.User.signUp("tdurden", "mayhem", {
  1170.       ACL: new Parse.ACL(),
  1171.       foo: "bar"
  1172.     }, {
  1173.       success: function() {
  1174.         Parse.User.logOut()
  1175.         .then(() => {
  1176.           Parse.User.logIn("tdurden", "mayhem", {
  1177.             success: function(user) {
  1178.               equal(user.get("foo"), "bar");
  1179.               done();
  1180.             },
  1181.             error: function(user, error) {
  1182.               ok(null, "Error " + error.id + ": " + error.message);
  1183.               done();
  1184.             }
  1185.           });
  1186.         });
  1187.       },
  1188.       error: function(user, error) {
  1189.         ok(null, "Error " + error.id + ": " + error.message);
  1190.         done();
  1191.       }
  1192.     });
  1193.   });
  1194.  
  1195.   it("query for included object with ACL works", (done) => {
  1196.     var obj1 = new Parse.Object("TestClass1");
  1197.     var obj2 = new Parse.Object("TestClass2");
  1198.     var acl = new Parse.ACL();
  1199.     acl.setPublicReadAccess(true);
  1200.     obj2.set("ACL", acl);
  1201.     obj1.set("other", obj2);
  1202.     obj1.save(null, expectSuccess({
  1203.       success: function() {
  1204.         obj2._clearServerData();
  1205.         var query = new Parse.Query("TestClass1");
  1206.         query.first(expectSuccess({
  1207.           success: function(obj1Again) {
  1208.             ok(!obj1Again.get("other").get("ACL"));
  1209.  
  1210.             query.include("other");
  1211.             query.first(expectSuccess({
  1212.               success: function(obj1AgainWithInclude) {
  1213.                 ok(obj1AgainWithInclude.get("other").get("ACL"));
  1214.                 done();
  1215.               }
  1216.             }));
  1217.           }
  1218.         }));
  1219.       }
  1220.     }));
  1221.   });
  1222.  
  1223.   it('restricted ACL does not have public access', (done) => {
  1224.     var obj = new Parse.Object("TestClassMasterACL");
  1225.     var acl = new Parse.ACL();
  1226.     obj.set('ACL', acl);
  1227.     obj.save().then(() => {
  1228.       var query = new Parse.Query("TestClassMasterACL");
  1229.       return query.find();
  1230.     }).then((results) => {
  1231.       ok(!results.length, 'Should not have returned object with secure ACL.');
  1232.       done();
  1233.     });
  1234.   });
  1235.  
  1236.   it('regression test #701', done => {
  1237.     const config = new Config('test');
  1238.     var anonUser = {
  1239.       authData: {
  1240.         anonymous: {
  1241.           id: '00000000-0000-0000-0000-000000000001'
  1242.         }
  1243.       }
  1244.     };
  1245.  
  1246.     Parse.Cloud.afterSave(Parse.User, req => {
  1247.       if (!req.object.existed()) {
  1248.         var user = req.object;
  1249.         var acl = new Parse.ACL(user);
  1250.         user.setACL(acl);
  1251.         console.log('IN AFTER SAVE!');
  1252.         user.save(null, {useMasterKey: true}).then(user => {
  1253.           new Parse.Query('_User').get(user.objectId).then(() => {
  1254.             fail('should not have fetched user without public read enabled');
  1255.             done();
  1256.           }, error => {
  1257.             expect(error.code).toEqual(Parse.Error.OBJECT_NOT_FOUND);
  1258.             done();
  1259.           });
  1260.         }, done.fail);
  1261.       }
  1262.     });
  1263.  
  1264.     rest.create(config, auth.nobody(config), '_User', anonUser)
  1265.   })
  1266. });
  1267.  
downloadParseACL.spec.js Source code - Download parse-server Source code
Related Source Codes/Software:
react-boilerplate - 2017-06-07
webtorrent - Streaming torrent client for the web ... 2017-06-06
machine-learning-for-software-engineers - A complete daily plan for studying to become a mac... 2017-06-06
upterm - A terminal emulator for the 21st century. 2017-06-06
lottie-android - Render After Effects animations natively on Androi... 2017-06-07
AsyncDisplayKit - Smooth asynchronous user interfaces for iOS apps. ... 2017-06-07
ionicons - The premium icon font for Ionic ... 2017-06-07
storybook - 2017-06-07
prettier - Prettier is an opinionated JavaScript formatter. ... 2017-06-08
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top