Add possibility to fake function with temp or derived tables (#53)

* Add possibility to fake function with temp or derived tables

* Remove wrongly removed new lines

* PR#53 Add new lines at the end of the files

* PR#53 Add missing schema for the table

* Remove test

* PR#53 Fix tests

* Change naming convention for the FakeFunction data output table name

* Fix issue with the long function names

* Add FakeFunction test for long name and output table schema

* Add test for data source table starting with SELECT

* Using tSQLt.Private::CreateUniqueObjectName() to generate random object name

* Remove `FunctionName` parameter

* Change build order as CLR is used

* Fix fake functions test

* Add CLR function exception message test

* Remove CONCAT usage

* Add CLR TVF support

Author: dkultasev

Source/BuildOrder.txt

@@ -25,6 +25,7 @@ tSQLt.CaptureOutputLog.tbl.sql
 tSQLt.LogCapturedOutput.ssp.sql
 ../Build/temp/CreateAssembly.sql
 tSQLtCLR_CreateProcs.sql
+tSQLt.Private_PrepareFakeFunctionOutputTable.ssp.sql
 tSQLt.TableToText.ssp.sql
 tSQLt.Private_RenamedObjectLog.tbl.sql
 tSQLt.Private_MarkObjectBeforeRename.ssp.sql

Source/tSQLt.FakeFunction.ssp.sql

@@ -3,8 +3,10 @@ GO
 ---Build+
 GO
 CREATE PROCEDURE tSQLt.FakeFunction
-  @FunctionName NVARCHAR(MAX),
-  @FakeFunctionName NVARCHAR(MAX)
+  @FunctionName     NVARCHAR(MAX),
+  @FakeFunctionName NVARCHAR(MAX) = NULL,
+  @FakeDataSource   NVARCHAR(MAX) = NULL
+
 AS
 BEGIN
   DECLARE @FunctionObjectId INT;
@@ -14,6 +16,7 @@ BEGIN
   EXEC tSQLt.Private_ValidateObjectsCompatibleWithFakeFunction 
                @FunctionName = @FunctionName,
                @FakeFunctionName = @FakeFunctionName,
+               @FakeDataSource   = @FakeDataSource,
                @FunctionObjectId = @FunctionObjectId OUT,
                @FakeFunctionObjectId = @FakeFunctionObjectId OUT,
                @IsScalarFunction = @IsScalarFunction OUT;
@@ -23,6 +26,7 @@ BEGIN
   EXEC tSQLt.Private_CreateFakeFunction 
                @FunctionName = @FunctionName,
                @FakeFunctionName = @FakeFunctionName,
+               @FakeDataSource   = @FakeDataSource,
                @FunctionObjectId = @FunctionObjectId,
                @FakeFunctionObjectId = @FakeFunctionObjectId,
                @IsScalarFunction = @IsScalarFunction;

Source/tSQLt.Private_CreateFakeFunction.ssp.sql

@@ -3,11 +3,12 @@ GO
 ---Build+
 GO
 CREATE PROCEDURE tSQLt.Private_CreateFakeFunction
-  @FunctionName NVARCHAR(MAX),
-  @FakeFunctionName NVARCHAR(MAX),
-  @FunctionObjectId INT,
-  @FakeFunctionObjectId INT,
-  @IsScalarFunction BIT
+  @FunctionName         NVARCHAR(MAX),
+  @FakeFunctionName     NVARCHAR(MAX) = NULL,
+  @FunctionObjectId     INT = NULL,
+  @FakeFunctionObjectId INT = NULL,
+  @IsScalarFunction     BIT = NULL,
+  @FakeDataSource       NVARCHAR(MAX) = NULL 
 AS
 BEGIN
   DECLARE @ReturnType NVARCHAR(MAX);
@@ -44,6 +45,12 @@ BEGIN
   BEGIN
     EXEC('CREATE FUNCTION '+@FunctionName+'('+@ParameterList+') RETURNS '+@ReturnType+' AS BEGIN RETURN '+@FakeFunctionName+'('+@ParameterCallList+');END;');	
   END
+  ELSE IF (@FakeDataSource IS NOT NULL)
+  BEGIN
+    DECLARE @newTbleName NVARCHAR(MAX);
+    EXEC tSQLt.Private_PrepareFakeFunctionOutputTable @FakeDataSource, @newTbleName OUTPUT;
+    EXEC ('CREATE FUNCTION '+@FunctionName+'('+@ParameterList+') RETURNS TABLE AS RETURN ( SELECT * FROM '+@newTbleName+');');
+  END
   ELSE
   BEGIN
     EXEC('CREATE FUNCTION '+@FunctionName+'('+@ParameterList+') RETURNS TABLE AS RETURN SELECT * FROM '+@FakeFunctionName+'('+@ParameterCallList+');');	

Source/tSQLt.Private_PrepareFakeFunctionOutputTable.ssp.sql

@@ -0,0 +1,26 @@
+IF OBJECT_ID('tSQLt.Private_PrepareFakeFunctionOutputTable') IS NOT NULL
+    DROP PROCEDURE tSQLt.Private_PrepareFakeFunctionOutputTable;
+GO
+---Build+
+CREATE PROCEDURE tSQLt.Private_PrepareFakeFunctionOutputTable
+    @FakeDataSource NVARCHAR(MAX),
+    @OutputTable    NVARCHAR(MAX) OUTPUT
+AS
+    BEGIN
+        SET @OutputTable = tSQLt.Private::CreateUniqueObjectName();
+
+        IF ( LOWER(LTRIM(@FakeDataSource)) LIKE 'select%'
+             AND OBJECT_ID(@FakeDataSource) IS NULL
+           )
+            BEGIN
+                SET @FakeDataSource = N'('+ @FakeDataSource + N') a';
+            END;
+
+        DECLARE @Cmd NVARCHAR(MAX) = N'SELECT * INTO ' + @OutputTable + N' FROM ' + @FakeDataSource;
+
+        EXEC sp_executesql @Cmd;
+
+        RETURN 0;
+    END;
+---Build-
+GO

Source/tSQLt.Private_ValidateObjectsCompatibleWithFakeFunction.ssp.sql

@@ -3,20 +3,44 @@ GO
 ---Build+
 GO
 CREATE PROCEDURE tSQLt.Private_ValidateObjectsCompatibleWithFakeFunction
-  @FunctionName NVARCHAR(MAX),
-  @FakeFunctionName NVARCHAR(MAX),
-  @FunctionObjectId INT OUTPUT,
-  @FakeFunctionObjectId INT OUTPUT,
-  @IsScalarFunction BIT OUTPUT
+  @FunctionName         NVARCHAR(MAX),
+  @FakeFunctionName     NVARCHAR(MAX) = NULL,
+  @FakeDataSource       NVARCHAR(MAX) = NULL,
+  @FunctionObjectId     INT = NULL OUTPUT,
+  @FakeFunctionObjectId INT = NULL OUTPUT,
+  @IsScalarFunction     BIT = NULL OUTPUT
 AS
 BEGIN
   SET @FunctionObjectId = OBJECT_ID(@FunctionName);
-  SET @FakeFunctionObjectId = OBJECT_ID(@FakeFunctionName);
 
   IF(@FunctionObjectId IS NULL)
   BEGIN
     RAISERROR('%s does not exist!',16,10,@FunctionName);
   END;
+
+   IF COALESCE(@FakeFunctionName, @FakeDataSource) IS NULL
+   BEGIN
+      RAISERROR ('Either @FakeFunctionName or @FakeDataSource must be provided', 16, 10);
+   END;
+
+   IF (@FakeFunctionName  IS NOT NULL  AND @FakeDataSource IS NOT NULL )
+   BEGIN
+      RAISERROR ('Both @FakeFunctionName and @FakeDataSource are valued. Please use only one.', 16, 10);
+   END;
+
+   IF (@FakeDataSource IS NOT NULL ) 
+   BEGIN
+      IF NOT EXISTS (
+         SELECT 1 FROM sys.objects WHERE object_id = OBJECT_ID(@FunctionName) and type in ('TF', 'IF', 'FT')
+      ) 
+      BEGIN
+         RAISERROR('You can use @FakeDataSource only with Inline, Multi-Statement or CLR Table-Valued functions.', 16, 10);
+      END
+    
+	  RETURN 0;
+   END
+
+  SET @FakeFunctionObjectId = OBJECT_ID(@FakeFunctionName);
   IF(@FakeFunctionObjectId IS NULL)
   BEGIN
     RAISERROR('%s does not exist!',16,10,@FakeFunctionName);
@@ -50,4 +74,3 @@ BEGIN
   END;	
 END;
 GO
-  

Tests/FakeFunctionTests.class.sql

@@ -422,6 +422,156 @@ BEGIN
   EXEC FakeFunctionTests.[assert parameter missmatch causes error];
 END;
 GO
+CREATE PROCEDURE FakeFunctionTests.[test errors when both @FakeFunctionName and @FakeDataSource are passed]
+AS
+BEGIN
+  EXEC('CREATE FUNCTION FakeFunctionTests.AFunction(@a int, @b int) RETURNS TABLE AS RETURN (SELECT @a AS one);');
+  EXEC tSQLt.ExpectException @ExpectedMessage = 'Both @FakeFunctionName and @FakeDataSource are valued. Please use only one.', @ExpectedSeverity = 16, @ExpectedState = 10;
+  EXEC tSQLt.FakeFunction @FunctionName = 'FakeFunctionTests.AFunction', @FakeFunctionName = 'FakeFunctionTests.AFunction', @FakeDataSource = 'select 1 one';
+END;
+GO
+CREATE PROCEDURE FakeFunctionTests.[test errors when neither @FakeFunctionName nor @FakeDataSource are passed]
+AS
+BEGIN
+  EXEC('CREATE FUNCTION FakeFunctionTests.AFunction(@a int, @b int) RETURNS TABLE AS RETURN (SELECT @a AS one);');
+  EXEC tSQLt.ExpectException @ExpectedMessage = 'Either @FakeFunctionName or @FakeDataSource must be provided', @ExpectedSeverity = 16, @ExpectedState = 10;
+  EXEC tSQLt.FakeFunction @FunctionName = 'FakeFunctionTests.AFunction';
+END;
+GO
+CREATE PROCEDURE FakeFunctionTests.[test errors if function is a SVF and @FakeDataSource is used]
+AS
+BEGIN
+  EXEC('CREATE FUNCTION FakeFunctionTests.AFunction() RETURNS NVARCHAR(10) AS BEGIN RETURN ''''; END;');
+
+  EXEC tSQLt.ExpectException @ExpectedMessage = 'You can use @FakeDataSource only with Inline, Multi-Statement or CLR Table-Valued functions.', 
+                             @ExpectedSeverity = 16, 
+                             @ExpectedState = 10;  
+
+  EXEC tSQLt.FakeFunction @FunctionName = 'FakeFunctionTests.AFunction', @FakeDataSource = 'select 1 as a';
+
+END;
+GO
+CREATE PROCEDURE FakeFunctionTests.[test errors if function is a CLR SVF and @FakeDataSource is used]
+AS
+BEGIN
+  EXEC('CREATE FUNCTION FakeFunctionTests.AFunction() RETURNS NVARCHAR(10) AS BEGIN RETURN ''''; END;');
+
+  EXEC tSQLt.ExpectException @ExpectedMessage = 'You can use @FakeDataSource only with Inline, Multi-Statement or CLR Table-Valued functions.', 
+                             @ExpectedSeverity = 16, 
+                             @ExpectedState = 10;  
+
+  EXEC tSQLt.FakeFunction @FunctionName = 'FakeFunctionTests.AFunction', @FakeDataSource = 'select 1 as a';
+
+END;
+GO
+CREATE PROCEDURE FakeFunctionTests.[test can fake Inline table function using a temp table as fake data source]
+AS
+BEGIN
+  EXEC('CREATE FUNCTION FakeFunctionTests.AFunction() RETURNS TABLE AS RETURN (SELECT  1 AS one);');
+
+  CREATE TABLE #expected (a CHAR(1));
+  INSERT INTO #expected VALUES('a');
+
+  EXEC tSQLt.FakeFunction @FunctionName = 'FakeFunctionTests.AFunction', @FakeDataSource = '#expected';
+
+  SELECT * INTO #actual FROM FakeFunctionTests.AFunction();
+
+  EXEC tSQLt.AssertEqualsTable '#expected', '#actual';
+END;
+GO
+CREATE PROCEDURE FakeFunctionTests.[test can fake multi-statement table function using a temp table as fake data source]
+AS
+BEGIN
+  EXEC('CREATE FUNCTION FakeFunctionTests.AFunction(@a int) RETURNS @t TABLE (a int) AS BEGIN;
+ INSERT INTO @t (a) VALUES (0) RETURN; END;');
+
+  CREATE TABLE #expected (a CHAR(1));
+  INSERT INTO #expected VALUES('a');
+
+  EXEC tSQLt.FakeFunction @FunctionName = 'FakeFunctionTests.AFunction', @FakeDataSource = '#expected';
+
+  SELECT * INTO #actual FROM FakeFunctionTests.AFunction(123);
+
+  EXEC tSQLt.AssertEqualsTable '#expected', '#actual';
+END;
+GO
+CREATE PROCEDURE FakeFunctionTests.[test can fake CLR table function using a temp table as fake data source]
+AS
+BEGIN
+
+  CREATE TABLE #expected (a CHAR(1));
+  INSERT INTO #expected VALUES('a');
+
+  EXEC tSQLt.FakeFunction @FunctionName = 'tSQLt_testutil.AClrTvf', @FakeDataSource = '#expected';
+
+  SELECT * INTO #actual FROM tSQLt_testutil.AClrTvf('', '');
+
+  EXEC tSQLt.AssertEqualsTable '#expected', '#actual';
+END;
+GO
+CREATE PROCEDURE FakeFunctionTests.[test can fake function with one parameter]
+AS
+BEGIN
+  EXEC('CREATE FUNCTION FakeFunctionTests.AFunction(@a int) RETURNS TABLE AS RETURN (SELECT @a AS one);');
+
+  CREATE TABLE #expected (a INT);
+  INSERT INTO #expected VALUES(1);
+
+  EXEC tSQLt.FakeFunction @FunctionName = 'FakeFunctionTests.AFunction', @FakeDataSource = '#expected';
+
+  SELECT * INTO #actual FROM FakeFunctionTests.AFunction(123);
+
+  EXEC tSQLt.AssertEqualsTable '#expected', '#actual';
+END;
+GO
+CREATE PROCEDURE FakeFunctionTests.[test can fake function with multiple parameters]
+AS
+BEGIN
+  EXEC('CREATE FUNCTION FakeFunctionTests.AFunction(@a int, @b int, @c char(1)) RETURNS TABLE AS RETURN (SELECT @a AS one);');
+
+  CREATE TABLE #expected (a INT);
+  INSERT INTO #expected VALUES(1);
+
+  EXEC tSQLt.FakeFunction @FunctionName = 'FakeFunctionTests.AFunction', @FakeDataSource = '#expected';
+
+  SELECT * INTO #actual FROM FakeFunctionTests.AFunction(123, 321, 'a');
+
+  EXEC tSQLt.AssertEqualsTable '#expected', '#actual';
+END;
+GO
+CREATE PROCEDURE FakeFunctionTests.[test can fake function with VALUES clause as fake data source]
+AS
+BEGIN
+  EXEC('CREATE FUNCTION FakeFunctionTests.AFunction() RETURNS TABLE AS RETURN (SELECT 777 AS a);');
+
+  CREATE TABLE #expected (a INT);
+  INSERT INTO #expected VALUES(1);
+
+  EXEC tSQLt.FakeFunction @FunctionName = 'FakeFunctionTests.AFunction', @FakeDataSource = '(VALUES(1)) a(a)';
+
+  SELECT * INTO #actual FROM FakeFunctionTests.AFunction();
+
+  EXEC tSQLt.AssertEqualsTable '#expected', '#actual';
+END;
+GO
+CREATE PROCEDURE FakeFunctionTests.[test can fake function with two part named table as fake data source]
+AS
+BEGIN
+  EXEC('CREATE FUNCTION FakeFunctionTests.AFunction() RETURNS TABLE AS RETURN (SELECT 777 AS a);');
+
+  CREATE TABLE #expected (a INT);
+  INSERT INTO #expected VALUES(1);
+
+  SELECT * INTO FakeFunctionTests.SomeTable FROM #expected;
+
+
+  EXEC tSQLt.FakeFunction @FunctionName = 'FakeFunctionTests.AFunction', @FakeDataSource = 'FakeFunctionTests.SomeTable';
+
+  SELECT * INTO #actual FROM FakeFunctionTests.AFunction();
+
+  EXEC tSQLt.AssertEqualsTable '#expected', '#actual';
+END;
+GO
 CREATE TYPE FakeFunctionTests.TableType1001 AS TABLE(SomeInt INT);
 GO
 CREATE PROCEDURE FakeFunctionTests.[test can fake function with table-type parameter]
@@ -442,4 +592,69 @@ BEGIN
   EXEC tSQLt.AssertEqualsString @Expected = 233515, @Actual = @Actual;
 END;
 GO
+CREATE PROCEDURE FakeFunctionTests.[test can fake with derived table]
+AS
+BEGIN
+  EXEC('CREATE FUNCTION FakeFunctionTests.AFunction() RETURNS TABLE AS RETURN (SELECT 777 AS a);');
+
+  CREATE TABLE #expected (a INT);
+  INSERT INTO #expected VALUES(1);
+
+  CREATE TABLE #actual (a INT)
+
+  EXEC tSQLt.FakeFunction @FunctionName = 'FakeFunctionTests.AFunction', @FakeDataSource = 'select 1 as a';
+
+  INSERT INTO #actual SELECT * FROM FakeFunctionTests.AFunction();
+
+  EXEC tSQLt.AssertEqualsTable '#expected', '#actual';
+END;
+GO
+CREATE PROCEDURE FakeFunctionTests.[test can fake with data source table that starts with select]
+AS
+BEGIN
+  DECLARE @Expected INT = 1;
+  DECLARE @Actual INT = 0;
+
+  EXEC('CREATE FUNCTION FakeFunctionTests.AFunction() RETURNS TABLE AS RETURN (SELECT 777 AS a);');
+
+  CREATE TABLE SelectFakeFunctionTestsTable (a int);
+  INSERT INTO SelectFakeFunctionTestsTable VALUES (@Expected);
+
+  EXEC tSQLt.FakeFunction @FunctionName = 'FakeFunctionTests.AFunction', 
+                         @FakeDataSource = N'SelectFakeFunctionTestsTable';
+  
+  SELECT @Actual = a FROM FakeFunctionTests.AFunction()
+  EXEC tSQLt.AssertEquals @Expected, @Actual;
+
+END;
+GO
+CREATE PROCEDURE FakeFunctionTests.[test Private_PrepareFakeFunctionOutputTable returns table with VALUES]
+AS
+BEGIN
+
+  DECLARE @NewTable sysname;
 
+  CREATE TABLE #Expected (a int);
+  INSERT INTO #Expected VALUES(1);
+  
+  EXEC tSQLt.Private_PrepareFakeFunctionOutputTable '(VALUES (1)) a(a)', @NewTable OUTPUT;
+
+  EXEC tSQLt.AssertEqualsTable '#Expected', @NewTable;
+
+END;
+GO
+CREATE PROCEDURE FakeFunctionTests.[test Private_PrepareFakeFunctionOutputTable returns table with SELECT query]
+AS
+BEGIN
+
+  DECLARE @NewTable sysname;
+
+  CREATE TABLE #Expected (a int);
+  INSERT INTO #Expected VALUES(1);
+  
+  EXEC tSQLt.Private_PrepareFakeFunctionOutputTable 'SELECT 1 AS a', @NewTable OUTPUT;
+
+  EXEC tSQLt.AssertEqualsTable '#Expected', @NewTable;
+
+END;
+GO