コード例 #1
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldSupportProcedureDeprecation() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void ShouldSupportProcedureDeprecation()
        {
            // Given
            Log log = mock(typeof(Log));
            ReflectiveProcedureCompiler procedureCompiler = new ReflectiveProcedureCompiler(new TypeMappers(), _components, _components, log, ProcedureConfig.Default);

            // When
            IList <CallableProcedure> procs = procedureCompiler.CompileProcedure(typeof(ProcedureWithDeprecation), null, true);

            // Then
            verify(log).warn("Use of @Procedure(deprecatedBy) without @Deprecated in badProc");
            verifyNoMoreInteractions(log);
            foreach (CallableProcedure proc in procs)
            {
                string name = proc.Signature().name().name();
                proc.Apply(new BasicContext(), new object[0], _resourceTracker);
                switch (name)
                {
                case "newProc":
                    assertFalse("Should not be deprecated", proc.Signature().deprecated().Present);
                    break;

                case "oldProc":
                case "badProc":
                    assertTrue("Should be deprecated", proc.Signature().deprecated().Present);
                    assertThat(proc.Signature().deprecated().get(), equalTo("newProc"));
                    break;

                default:
                    fail("Unexpected procedure: " + name);
                    break;
                }
            }
        }
コード例 #2
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldSupportFunctionDeprecation() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void ShouldSupportFunctionDeprecation()
        {
            // Given
            Log log = mock(typeof(Log));
            ReflectiveProcedureCompiler procedureCompiler = new ReflectiveProcedureCompiler(new TypeMappers(), _components, new ComponentRegistry(), log, ProcedureConfig.Default);

            // When
            IList <CallableUserFunction> funcs = procedureCompiler.CompileFunction(typeof(FunctionWithDeprecation));

            // Then
            verify(log).warn("Use of @UserFunction(deprecatedBy) without @Deprecated in org.neo4j.kernel.impl.proc.badFunc");
            verifyNoMoreInteractions(log);
            foreach (CallableUserFunction func in funcs)
            {
                string name = func.Signature().name().name();
                func.Apply(new BasicContext(), new AnyValue[0]);
                switch (name)
                {
                case "newFunc":
                    assertFalse("Should not be deprecated", func.Signature().deprecated().Present);
                    break;

                case "oldFunc":
                case "badFunc":
                    assertTrue("Should be deprecated", func.Signature().deprecated().Present);
                    assertThat(func.Signature().deprecated().get(), equalTo("newFunc"));
                    break;

                default:
                    fail("Unexpected function: " + name);
                    break;
                }
            }
        }
コード例 #3
0
ファイル: Procedures.cs プロジェクト: Neo4Net/Neo4Net
 public Procedures(EmbeddedProxySPI proxySPI, ThrowingConsumer <Procedures, ProcedureException> builtin, File pluginDir, Log log, ProcedureConfig config)
 {
     this._builtin     = builtin;
     this._pluginDir   = pluginDir;
     this._log         = log;
     this._typeMappers = new TypeMappers(proxySPI);
     this._compiler    = new ReflectiveProcedureCompiler(_typeMappers, _safeComponents, _allComponents, log, config);
 }
コード例 #4
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Before public void setUp()
        public virtual void SetUp()
        {
            ComponentRegistry safeComponents = new ComponentRegistry();
            ComponentRegistry allComponents  = new ComponentRegistry();

            safeComponents.Register(typeof(MyAwesomeAPI), ctx => new MyAwesomeAPI());
            allComponents.Register(typeof(MyAwesomeAPI), ctx => new MyAwesomeAPI());
            allComponents.Register(typeof(MyUnsafeAPI), ctx => new MyUnsafeAPI());

            _compiler = new ReflectiveProcedureCompiler(new TypeMappers(), safeComponents, allComponents, _log, ProcedureConfig.Default);
        }
コード例 #5
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldNotLoadAnyFunctionIfConfigIsEmpty() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void ShouldNotLoadAnyFunctionIfConfigIsEmpty()
        {
            // Given
            Log log = spy(typeof(Log));

            _procedureCompiler = new ReflectiveProcedureCompiler(new TypeMappers(), _components, new ComponentRegistry(), log, new ProcedureConfig(Config.defaults(GraphDatabaseSettings.procedure_whitelist, "")));

            IList <CallableUserFunction> method = Compile(typeof(SingleReadOnlyFunction));

            verify(log).warn("The function 'org.neo4j.kernel.impl.proc.listCoolPeople' is not on the whitelist and won't be loaded.");
            assertThat(method.Count, equalTo(0));
        }
コード例 #6
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldLoadWhiteListedFunction() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void ShouldLoadWhiteListedFunction()
        {
            // Given
            _procedureCompiler = new ReflectiveProcedureCompiler(new TypeMappers(), _components, new ComponentRegistry(), NullLog.Instance, new ProcedureConfig(Config.defaults(GraphDatabaseSettings.procedure_whitelist, "org.neo4j.kernel.impl.proc.listCoolPeople")));

            CallableUserFunction method = Compile(typeof(SingleReadOnlyFunction))[0];

            // Expect
            object @out = method.Apply(new BasicContext(), new AnyValue[0]);

            assertThat(@out, equalTo(ValueUtils.of(Arrays.asList("Bonnie", "Clyde"))));
        }
コード例 #7
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldLoadWhiteListedFunction() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void ShouldLoadWhiteListedFunction()
        {
            // Given
            _procedureCompiler = new ReflectiveProcedureCompiler(new TypeMappers(), _components, new ComponentRegistry(), NullLog.Instance, new ProcedureConfig(Config.defaults(GraphDatabaseSettings.procedure_whitelist, "org.neo4j.kernel.impl.proc.collectCool")));

            CallableUserAggregationFunction method = Compile(typeof(SingleAggregationFunction))[0];

            // Expect
            UserAggregator created = method.Create(new BasicContext());

            created.Update(new object[] { "Bonnie" });
            assertThat(created.Result(), equalTo(Collections.singletonList("Bonnie")));
        }
コード例 #8
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldNotLoadAnyProcedureIfConfigIsEmpty() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void ShouldNotLoadAnyProcedureIfConfigIsEmpty()
        {
            // Given
            ProcedureConfig             config            = new ProcedureConfig(Config.defaults(procedure_whitelist, ""));
            Log                         log               = mock(typeof(Log));
            ReflectiveProcedureCompiler procedureCompiler = new ReflectiveProcedureCompiler(new TypeMappers(), _components, _components, log, config);

            // When
            IList <CallableProcedure> proc = procedureCompiler.CompileProcedure(typeof(SingleReadOnlyProcedure), null, false);

            // Then
            verify(log).warn("The procedure 'org.neo4j.kernel.impl.proc.listCoolPeople' is not on the whitelist and won't be loaded.");
            assertThat(proc.Count == 0, @is(true));
        }
コード例 #9
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldIgnoreWhiteListingIfFullAccess() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void ShouldIgnoreWhiteListingIfFullAccess()
        {
            // Given
            ProcedureConfig             config            = new ProcedureConfig(Config.defaults(procedure_whitelist, "empty"));
            Log                         log               = mock(typeof(Log));
            ReflectiveProcedureCompiler procedureCompiler = new ReflectiveProcedureCompiler(new TypeMappers(), _components, _components, log, config);

            // When
            CallableProcedure proc = procedureCompiler.CompileProcedure(typeof(SingleReadOnlyProcedure), null, true)[0];
            // Then
            RawIterator <object[], ProcedureException> result = proc.Apply(new BasicContext(), new object[0], _resourceTracker);

            assertEquals(result.Next()[0], "Bonnie");
        }
コード例 #10
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldLoadWhiteListedProcedure() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void ShouldLoadWhiteListedProcedure()
        {
            // Given
            ProcedureConfig config = new ProcedureConfig(Config.defaults(procedure_whitelist, "org.neo4j.kernel.impl.proc.listCoolPeople"));

            Log log = mock(typeof(Log));
            ReflectiveProcedureCompiler procedureCompiler = new ReflectiveProcedureCompiler(new TypeMappers(), _components, _components, log, config);

            // When
            CallableProcedure proc = procedureCompiler.CompileProcedure(typeof(SingleReadOnlyProcedure), null, false)[0];
            // When
            RawIterator <object[], ProcedureException> result = proc.Apply(new BasicContext(), new object[0], _resourceTracker);

            // Then
            assertEquals(result.Next()[0], "Bonnie");
        }
コード例 #11
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Before public void setUp()
        public virtual void SetUp()
        {
            _components        = new ComponentRegistry();
            _procedureCompiler = new ReflectiveProcedureCompiler(new TypeMappers(), _components, _components, NullLog.Instance, ProcedureConfig.Default);
        }
コード例 #12
0
 internal ProcedureJarLoader(ReflectiveProcedureCompiler compiler, Log log)
 {
     this._compiler = compiler;
     this._log      = log;
 }