From 688a1a7762801e4e992dec73d472b6819acc4e61 Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Thu, 23 Jan 2025 14:04:17 +0100 Subject: [PATCH 01/41] init work, before review, without cicd --- .../parameters_aws_auth_tests.json.gpg | Bin 0 -> 859 bytes .../parameters/rsa_keys/rsa_key.p8.gpg | Bin 0 -> 1401 bytes .../rsa_keys/rsa_key_invalid.p8.gpg | Bin 0 -> 1409 bytes .../AuthConnectionParameters.cs | 181 ++++++++++++++++++ .../AuthenticationTests/AuthTestHelper.cs | 159 +++++++++++++++ .../ExternalBrowserConnection.cs | 90 +++++++++ .../AuthenticationTests/KeyPairConnection.cs | 77 ++++++++ .../AuthenticationTests/OauthConnection.cs | 56 ++++++ .../AuthenticationTests/OktaConnection.cs | 81 ++++++++ 9 files changed, 644 insertions(+) create mode 100644 .github/workflows/parameters/parameters_aws_auth_tests.json.gpg create mode 100644 .github/workflows/parameters/rsa_keys/rsa_key.p8.gpg create mode 100644 .github/workflows/parameters/rsa_keys/rsa_key_invalid.p8.gpg create mode 100644 Snowflake.Data.Tests/AuthenticationTests/AuthConnectionParameters.cs create mode 100644 Snowflake.Data.Tests/AuthenticationTests/AuthTestHelper.cs create mode 100644 Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs create mode 100644 Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs create mode 100644 Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs create mode 100644 Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs diff --git a/.github/workflows/parameters/parameters_aws_auth_tests.json.gpg b/.github/workflows/parameters/parameters_aws_auth_tests.json.gpg new file mode 100644 index 0000000000000000000000000000000000000000..73e16bc4284d5ae1dc3ab82be4e16364b2e38c37 GIT binary patch literal 859 zcmV-h1El6RpO6ArtgaG&W4JbmIf41B0?fQpMR-f=~Iq57Kv)bm;R_5U=*Yi~_gR#tbl>=RvD zhWMIh1HREY-p&s9qNXv`sy!J`FekObQulI7axxoBUyC@lA92Zp&JR#Vc7hdLzzOV8 zo={))Hc~S~hu5t$fJ7n><8cKig0BG5p5*EzcdsR8uX4Pyp(Rci=L6b}fS0+xLXRF& zL$9IBQgW_bFjN$yzP|C;nP4sQ1hm%vup!>37CcVJ!lIogne~)u3_5_}>UVsQ?gk0$UK? za!$jvki)5n*AJ(F!@@UMA1#1l8l*QH(LAchrCk^tC9Wgz=ktpPe*)tQR&V-hCGT5-^dg~G44z;uf~!$R;jqO2OxB0Sca`P+{Rny%G8*uZaN%liCDQt$&_y{;2tr;yrPL6b$LKiC< zG%A9*(h3Bb6xh{_?M3Bqz=*cn;!r!5!LH4gTIU56MA6dF(wP?4`icDbwwwU)lata(7h?HFU;Ft0#JT3V27F}2fKK0JGvd)-e;s$voNfd0q4UkI=W^l0tA)toFQmjQ;A^=sAUEI%-{gxA)O- z&Heq=G3#sv6=Zu{fP#7=!KW;>EFwg0sDY`L=|m{hT+n7j06_Dim6=VK$p^;s$k8FA zDL9{S`qO1I<;=1sZKi2|{b5x9ER3dU!{bO#H=Q`;=h%u8G~_J4Fm}T2sW}O5FyLDc>mJs0h2d8Frh+x^{u3Pa0SMoLHH6?e=*-mjvgH> z2vLe85YdPlUO(Q!9!pSB6A>H&jweedm{s1V#ne)B?*Ew@rwU_b#TnM9;UhFx3To6t z_P6?=sU*gyF;QLA_#Mo$(kPi1(JXYTssT|^+$&x*L$Eevm!oS`|43p5;KmqU%^l%$ zf+r)?+eT*09Xu(o5iEK_joJ$}Dsa`pjGsmZ`mI2lp`mFRNV1sTd0Ci*okFH%AmE-; zd+4|J!QjPk6^BSXKqE0mf|TlZ2zaMlTbpXsC}8o<%fLM^&iVvao*?ml+)$0U$bpAs zLH3TUT={fDCfq?VMddD_#HP=Ix7ckQ9C~_R0%&T!)P+`x2!}dM`3Kl20N3Op6C{~Z zk%{y}8JDX^xOP(EJHGc%(w2EuKHp1HMsLfzY%s9N>vQ-ncyy|Qjq?>IM#&zzy$VRR zr%PD_0L5TZ=Fq+8=!nISW!w4d)Xi~Qk&z;<)M=*IY0|V2k9kxLJ6xnHG=GW{Bg392 zo?6Jztg?5>fX#J^fhUfm$i9b1;ZAon)7!0dn2$1FkNQp#N_7b@%US|Ee+O>>6c8F4 z8a;2=rr9|#bXujzitOi+FSk`y)kNpN4i;$@tv4=b7o%a>uN;EdP^E?n_Q-{wPYw~N z|47S7IEO?Ln4ASaGSR=-{Pc#}G1?1n7$VDvPU~-ssYO&VbeM{lQ6Tp~cqGaD@u7^Q zI=D!g8j<4D=f7>QH~i4K*5V~kiz6_G@_&}0$@Ie*VgJ|q0mU-bVrDgK z_UU*pcX31M|Du$yhr*09q5N?I+Obt52dlq~F=T{M%>_PfJG&tD;yh$2qBNa0W78(P z7EH4YTCLzV3LEsaoI0=+vSlhsLYl05tRpzAMgiTn$G;mh*}Oz(beRb=+xUafENnD=V(wydV*G}ytLhk*&7QzvwqgUs=o-nJZ-IS zyIN22BCd+3IHMThQ_=?Ln=Z32HzU$-b^bf9-<7+E^Oe1i{7Dw>UUYPFfpKM zSJm^uuFIae{#^76r5G*dmsT@A!OKNo+nngu#=P3_}|z{JF#59A&4vatGc8TE>m`%l%m`jfVV^uj=t}2 zJrjj9LIj(iz@|1G{v+ne-Lu2Ma4?|)pY)`d7DVN&Mdu+ns=?BFgXcUpL>bfKjT)e^ z5#Oe^lh5|RCake@4!5fn+xoS3alDz$xCmS=-X%uTwpF6O@}3q#d~ql~M| z{kB*tpL=a+_a;5=UL!Dn=AI8#{FjG}b6lG2D_3jMpT61#hB#NJmASwqAG~!GxUJKz z4_kZU4Uh;r7}q4lRX{b!1gC|6Hy!yLx=(TabS-?4vr6ah6S(+)C!Sa9Ta?{g4vRQ{ zO8cfZ?^Cr!d+yUXE#jo78AFzI7^KK>Q|5XOhg20-DxIyW%1Va#`!v#!;>>o_8w@+y@ HBt6`SeZ8+W literal 0 HcmV?d00001 diff --git a/.github/workflows/parameters/rsa_keys/rsa_key_invalid.p8.gpg b/.github/workflows/parameters/rsa_keys/rsa_key_invalid.p8.gpg new file mode 100644 index 0000000000000000000000000000000000000000..3d2442a7c8c319f53ac8d6af8b12bcff78a364da GIT binary patch literal 1409 zcmV-{1%CRB4Fm}T2oOE^p^$#mNB`350dCH$DrP24&;&c@7=1}8SgJ`t2Jhbld~Tl6 z0G^#)CvI%Mkv<0lD%2OXL2~H0fW4z>z(2$S(~kytf&DxtVS*9dICkcS+ffG~Z})uY zB`zl9fytg}f2tY#aS$7$`dU!eSG^#6UQrisepTgBF1~k(CjXE)AYQUTzEc--YbK}u zfsLh_J)DoV(9go0v$9Lt*l~ZQa4WUnT`63VpmmGnc8nyJjA-hQ*mB*#+OG1a7ASWB ze9Raxfi?A`6~)p!PMM?gM{9IagV-L({Z#oVi}JuWJi|)kx!>=yOrS9Gq5B-*7@l)) z{1{^`_X~Fv&Doaj))DjJ-L^W*9SS1i*gV(ca; zCE#)|nKO-5uH?~G%8AdGged-2(o6$lg?(fJ4+X01x(E6BVUjyzwz#mG9;gAgohtx= z+&#TCKz~*>R9}QeY_}#N+573zc^{U_Y4gN;>sP>M4jpt_~jH>I~>|f z@HAD^fpJJ@X(hwEc(W@+EO*05}n$URL!)yDLn$0&x z^Y^TAlbtX(ef+HM*}-W=_w*kkq{JQnh7gX=9dA%?Uj;erdH&Br>=oUw^F_@8# zLANF=N8ti7r*?em#%jnoCdOAhX5?oaWg<8t>FGIOrHxIeM@3$j&RnDKL$ZO^m($@tnS=DJfQX8u0o%kqgA|Ez(3Xdev20sf`K49<(%)+s=$Lqn7cLK zcYr+C2QO{oaBUN&oPOqMtoXcn*^>5AfVW*-OjbrWWwCs<;gyMKQ_0~e9`Pd2^zd>R zPX&|_DioP6LIMMh`;dZ*njth+Ku%Gg29O|p4;>}oQFCY>4qILxtFqk;)Bc%ZF3f)+`?qFwQwiKph#32+tK`; z=hK)V8LHpTW2$|D8@l``@kxvrP5`g*-?MM*%hfFnknxU z8cM#TPhCW@difY~FYFCSv86g8s5|^8##L%J7Ja|v+O~qJJ-y}x5Zh}k_BaO;v=2G` z+ny&dA%H9;I6Ct#0(NHo*n(D4L>KHT*TeodHh;rXV#}gki)mI%l-}(jmh@%C=yj&+ zS&Cj=Jp0|>K~z)V(Z4UOueoNTy4huPrFV~!yPZp;MUU5kNFE>N@{W&7(!v#LnSkIr zRv~<=iZTb7zF~)46dwn2zL%K#j?aMpW8ffUfnkv<{;fKOMqmyh5>jTxsWit;I&THD zL{Eh#W~~%SQQ8F3URzklBVsset&u0^faeR4!Z66t3mnorN#pDIQGk~3E%IowD9NC0 Plk!d)KNyEuj^Ur;bOOha literal 0 HcmV?d00001 diff --git a/Snowflake.Data.Tests/AuthenticationTests/AuthConnectionParameters.cs b/Snowflake.Data.Tests/AuthenticationTests/AuthConnectionParameters.cs new file mode 100644 index 000000000..e75806294 --- /dev/null +++ b/Snowflake.Data.Tests/AuthenticationTests/AuthConnectionParameters.cs @@ -0,0 +1,181 @@ +using System; +using System.Collections.Generic; +using System.Net; +using System.Text; +using System.Collections.Specialized; +using Newtonsoft.Json.Linq; +using NUnit.Framework; +using System.IO; + +namespace Snowflake.Data.Tests.AuthenticationTests + +{ + static class AuthConnectionParameters + { + public static readonly string SsoUser = Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_BROWSER_USER"); + public static readonly string Host = Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_HOST"); + public static readonly string SsoPassword = Environment.GetEnvironmentVariable("SNOWFLAKE_TEST_OKTA_PASS"); + public static readonly string Okta = Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_OKTA_NAME"); + public static readonly string OauthPassword = Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_EXTERNAL_OAUTH_OKTA_USER_PASSWORD"); + public static Dictionary GetBaseConnectionParameters() + { + var properties = new Dictionary + { + { "host", Host }, + { "protocol", Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_PROTOCOL")}, + { "port", Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_PORT") }, + { "role", Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_ROLE") }, + { "account", Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_ACCOUNT") }, + { "db", Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_DATABASE") }, + { "schema", Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_SCHEMA") }, + { "warehouse", Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_WAREHOUSE") }, + }; + return properties; + } + + public static String SetBaseConnectionParameters(Dictionary param) + { + var basicConfig = String.Format("host={0};port={1};account={2};role={3};db={4};schema={5};warehouse={6};", + param["host"], param["port"], param["account"], param["role"], param["db"], param["schema"], param["warehouse"]); + return basicConfig; + } + + public static Dictionary GetExternalBrowserConnectionParameters() + { + var properties = GetBaseConnectionParameters(); + properties.Add("authenticator", "externalbrowser"); + properties.Add("user", Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_BROWSER_USER")); + // properties.Add("user", SsoUser); + return properties; + } + + public static String SetExternalBrowserConnectionParameters(Dictionary param) + { + var config = String.Format("{0}authenticator={1};user={2};", SetBaseConnectionParameters(param), param["authenticator"], param["user"]); + return config; + } + + public static Dictionary GetOauthConnectionParameters(string token) + { + var properties = GetBaseConnectionParameters(); + properties.Add("authenticator", "OAUTH"); + properties.Add("user", SsoUser); + properties.Add("token", token); + return properties; + } + + public static String SetOauthConnectionParameters(Dictionary param) + { + var config = String.Format("{0}authenticator={1};user={2};token={3}", SetBaseConnectionParameters(param), param["authenticator"], param["user"], param["token"]); + return config; + } + + public static Dictionary GetStoreIdTokenConnectionParameters(string token) + { + var properties = GetExternalBrowserConnectionParameters(); + properties.Add("CLIENT_STORE_TEMPORARY_CREDENTIAL", "true"); + return properties; + } + + public static Dictionary GetOktaConnectionParameters() + { + var properties = GetBaseConnectionParameters(); + properties.Add("authenticator", Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_OAUTH_URL")); + properties.Add("user", SsoUser); + properties.Add("password", SsoPassword); + + return properties; + } + + public static Dictionary GetKeyPairFromFileContentParameters(String privateKey) + { + + var properties = GetBaseConnectionParameters(); + properties.Add("authenticator", "snowflake_jwt"); + properties.Add("user", SsoUser); + + properties.Add("private_key", privateKey); + + return properties; + } + + + public static Dictionary GetKeyPairFromFilePathParameters(String privateKeyPath) + { + + var properties = GetBaseConnectionParameters(); + properties.Add("authenticator", "snowflake_jwt"); + properties.Add("user", AuthConnectionParameters.SsoUser); + properties.Add("private_key_file", privateKeyPath); + return properties; + } + public static String SetPrivateKeyFromFileContentParameters(Dictionary param) + { + var config = String.Format("{0}authenticator={1};private_key={2};user={3}", SetBaseConnectionParameters(param), param["authenticator"], param["private_key"], SsoUser); + return config; + } + + public static String SetPrivateKeyFromFilePathParameters(Dictionary param) + { + var config = String.Format("{0}authenticator={1};private_key_file={2};user={3}", SetBaseConnectionParameters(param),param["authenticator"], param["private_key_file"], SsoUser); + return config; + } + + public static String SetOktaConnectionParameters(Dictionary param) + { + var config = String.Format("{0}authenticator={1};user={2};password={3}", SetBaseConnectionParameters(param), param["authenticator"], param["user"], param["password"]); + return config; + } + + public static string GetPriavteKeyContentForKeypairAuth(string envName) + { + string filePath = Environment.GetEnvironmentVariable(envName); + Assert.IsNotNull(filePath); + string pemKey = File.ReadAllText("../../../../" + filePath); + Assert.IsNotNull(pemKey, $"Failed to read file: {filePath}"); + return pemKey; + + } + + public static string GetPriavteKeyPathForKeypairAuth(string envName) + { + string filePath = Environment.GetEnvironmentVariable(envName); + Assert.IsNotNull(filePath); + return Path.Combine("../../../../", filePath); + } + + public static string GetOauthToken() + { + try + { + using (var client = new WebClient()) + { + var values = new NameValueCollection(); + var authUrl = Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_OAUTH_URL"); + var clientId = Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_OAUTH_CLIENT_ID"); + var clientSecret = Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_OAUTH_CLIENT_SECRET"); + var credentials = Convert.ToBase64String(Encoding.ASCII.GetBytes($"{clientId}:{clientSecret}")); + + client.Headers[HttpRequestHeader.Authorization] = "Basic " + credentials; + + values["username"] = Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_OKTA_USER"); + values["password"] = Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_OKTA_PASS"); + values["grant_type"] = "password"; + values["scope"] = "session:role:" + Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_ROLE"); + + var fullResponse = Encoding.Default.GetString(client.UploadValues(authUrl, values)); + var responseString = JObject.Parse(fullResponse); + Assert.IsNotNull(responseString["access_token"]); + Console.WriteLine(responseString.ToString()); + return responseString["access_token"].ToString(); + } + } + catch (Exception e) + { + Console.WriteLine(e.Message); + return null; + } + + } + } +} diff --git a/Snowflake.Data.Tests/AuthenticationTests/AuthTestHelper.cs b/Snowflake.Data.Tests/AuthenticationTests/AuthTestHelper.cs new file mode 100644 index 000000000..335e49620 --- /dev/null +++ b/Snowflake.Data.Tests/AuthenticationTests/AuthTestHelper.cs @@ -0,0 +1,159 @@ +using System; +using System.Threading; +using System.Diagnostics; +using System.Data; +using NUnit.Framework; +using Snowflake.Data.Client; + +namespace Snowflake.Data.Tests.AuthenticationTests +{ + public class AuthTestHelper + { + private Exception _exception; + private readonly bool runAuthTestsManually; + public AuthTestHelper() + { + string envVar = Environment.GetEnvironmentVariable("RUN_AUTH_TESTS_MANUALLY"); + runAuthTestsManually = string.IsNullOrEmpty(envVar) ? true : bool.Parse(envVar); + } + + public void ProvideCredentials(string scenario, string login, string password) + { + try + { + String provideBrowserCredentialsPath = "/externalbrowser/provideBrowserCredentials.js"; + + var startInfo = new ProcessStartInfo + { + FileName = "node", + Arguments = provideBrowserCredentialsPath + " " + scenario + " " + login + " " + password, + RedirectStandardOutput = true, + RedirectStandardError = true, + UseShellExecute = false, + CreateNoWindow = true + }; + using (var process = new Process { StartInfo = startInfo }) + { + process.Start(); + if (!process.WaitForExit(15000)) // Wait for 15 seconds + { + process.Kill(); + throw new TimeoutException("The process did not complete in the allotted time."); + } + + string output = process.StandardOutput.ReadToEnd(); + string error = process.StandardError.ReadToEnd(); + + Console.WriteLine("Output: " + output); + Console.WriteLine("Error: " + error); + } + } + catch (Exception e) + { + _exception = e; + } + } + + public void cleanBrowserProcess() + { + if (!runAuthTestsManually) + { + try { + string cleanBrowserProcessesPath = "/externalbrowser/cleanBrowserProcesses.js"; + var startInfo = new ProcessStartInfo + { + FileName = "node", + Arguments = cleanBrowserProcessesPath, + RedirectStandardOutput = true, + RedirectStandardError = true, + UseShellExecute = false, + CreateNoWindow = true + }; + using (var process = new Process { StartInfo = startInfo }) + { + process.Start(); + if (!process.WaitForExit(20000)) // Wait for 15 seconds + { + process.Kill(); + throw new TimeoutException("The process did not complete in the allotted time."); + } + string output = process.StandardOutput.ReadToEnd(); + string error = process.StandardError.ReadToEnd(); + + Console.WriteLine("Output: " + output); + Console.WriteLine("Error: " + error); + } + } + catch (Exception e) + { + throw new Exception(e.ToString()); + } + } + } + + public void ConnectAndExecuteSimpleQuery(string connectionString) + { + try + { + using (IDbConnection conn = new SnowflakeDbConnection()) + { + conn.ConnectionString = connectionString; + + conn.Open(); + Assert.AreEqual(ConnectionState.Open, conn.State); + + + using (IDbCommand command = conn.CreateCommand()) + { + command.CommandText = "SELECT 1"; + var result = command.ExecuteScalar(); + Console.WriteLine(result.ToString()); + Assert.AreEqual("1", result.ToString()); + } + } + } + catch (SnowflakeDbException e) + { + _exception = e; + } + } + + public Thread getConnectAndExecuteSimpleQueryThread(string parameters) + { + return new Thread(() => ConnectAndExecuteSimpleQuery(parameters)); + } + + public Thread getProvideCredentialsThread(string scenario, string login, string password) + { + return new Thread(() => ProvideCredentials(scenario, login, password)); + } + + public void verifyExceptionIsNotThrown() { + Assert.That(_exception, Is.Null, "Unexpected exception thrown"); + } + + public void verifyExceptionIsThrown(string error) { + Assert.That(_exception, Is.Not.Null, "Expected exception was not thrown"); + Assert.That(_exception.Message, Does.Contain(error), "Unexpected exception message."); + + } + + public void connectAndProvideCredentials(Thread provideCredentialsThread, Thread connectThread) + { + if (runAuthTestsManually) + { + connectThread.Start(); + connectThread.Join(); + } + else + { + provideCredentialsThread.Start(); + connectThread.Start(); + provideCredentialsThread.Join(); + connectThread.Join(); + } + + } + } +} + diff --git a/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs new file mode 100644 index 000000000..14ee9db40 --- /dev/null +++ b/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs @@ -0,0 +1,90 @@ +/* + * Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved. + */ + +using System.Threading; +using NUnit.Framework; + +namespace Snowflake.Data.Tests.AuthenticationTests +{ + [NonParallelizable] + public class ExternalBrowserConnection : SFBaseTest + { + private string _connectionString = ""; + string _login = AuthConnectionParameters.SsoUser; + string _password = AuthConnectionParameters.SsoPassword; + AuthTestHelper authTestHelper = new AuthTestHelper(); + + [SetUp] + public void SetUp() + { + _login = AuthConnectionParameters.SsoUser; + _password = AuthConnectionParameters.SsoPassword; + authTestHelper.cleanBrowserProcess(); + var parameters = AuthConnectionParameters.GetExternalBrowserConnectionParameters(); + _connectionString = AuthConnectionParameters.SetExternalBrowserConnectionParameters(parameters); + } + + [Test, Order(1)] + public void TestAuthenticateUsingExternalBrowserSuccessful() + { + + Thread connectThread = authTestHelper.getConnectAndExecuteSimpleQueryThread(_connectionString); + Thread provideCredentialsThread = authTestHelper.getProvideCredentialsThread("success", _login, _password); + + authTestHelper.connectAndProvideCredentials(provideCredentialsThread, connectThread); + authTestHelper.verifyExceptionIsNotThrown(); + + } + + [Test, Order(2)] + public void TestAuthenticateUsingExternalBrowserMismatchedUser() + { + var parameters = AuthConnectionParameters.GetExternalBrowserConnectionParameters(); + + parameters["user"] = "differentUser"; + _connectionString = AuthConnectionParameters.SetExternalBrowserConnectionParameters(parameters); + + Thread connectThread = authTestHelper.getConnectAndExecuteSimpleQueryThread(_connectionString); + Thread provideCredentialsThread = authTestHelper.getProvideCredentialsThread("success", _login, _password); + + authTestHelper.connectAndProvideCredentials(provideCredentialsThread, connectThread); + authTestHelper.verifyExceptionIsThrown("The user you were trying to authenticate as differs from the user currently logged in at the IDP"); + + } + + [Test, Order(3)] + public void TestAuthenticateUsingExternalBrowserWrongCredentials() + { + var parameters = AuthConnectionParameters.GetExternalBrowserConnectionParameters(); + + _connectionString = AuthConnectionParameters.SetExternalBrowserConnectionParameters(parameters); + _connectionString += "BROWSER_RESPONSE_TIMEOUT=15;"; + + _login = "itsnotanaccount.com"; + _password = "fakepassword"; + + Thread connectThread = authTestHelper.getConnectAndExecuteSimpleQueryThread(_connectionString); + Thread provideCredentialsThread = authTestHelper.getProvideCredentialsThread("fail", _login, _password); + + authTestHelper.connectAndProvideCredentials(provideCredentialsThread, connectThread); + authTestHelper.verifyExceptionIsThrown("Browser response timed out after 15 seconds"); + + } + + [Test, Order(4)] + public void TestAuthenticateUsingExternalBrowserTimeout() + { + var parameters = AuthConnectionParameters.GetExternalBrowserConnectionParameters(); + + _connectionString = AuthConnectionParameters.SetExternalBrowserConnectionParameters(parameters); + _connectionString += "BROWSER_RESPONSE_TIMEOUT=1;"; + + Thread connectThread = authTestHelper.getConnectAndExecuteSimpleQueryThread(_connectionString); + Thread provideCredentialsThread = authTestHelper.getProvideCredentialsThread("timeout", _login, _password); + + authTestHelper.connectAndProvideCredentials(provideCredentialsThread, connectThread); + authTestHelper.verifyExceptionIsThrown("Browser response timed out after 1 seconds"); + } + } +} diff --git a/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs new file mode 100644 index 000000000..7d7d8c2fd --- /dev/null +++ b/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved. + */ + +using System; + +using NUnit.Framework; + + + +namespace Snowflake.Data.Tests.AuthenticationTests +{ + [NonParallelizable] + public class KeyPairConnection : SFBaseTest + { + private string _connectionString = ""; + + AuthTestHelper authTestHelper = new AuthTestHelper(); + + [SetUp] + public void SetUp() + { + + + } + + //TO BE UNCOMMENTED + // [Test, Order(1)] + // public void TestAuthenticateUsingKeyPairFilcContentSuccessful() + // { + // var privateKey = AuthConnectionParameters.GetPriavteKeyContentForKeypairAuth("SNOWFLAKE_AUTH_TEST_PRIVATE_KEY_PATH"); + // var parameters = AuthConnectionParameters.GetKeyPairFromFileContentParameters(privateKey); + // _connectionString = AuthConnectionParameters.SetPrivateKeyFromFileContentParameters(parameters); + // + // Console.WriteLine(_connectionString); + // authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); + // authTestHelper.verifyExceptionIsNotThrown(); + // } + + [Test, Order(2)] + public void TestAuthenticateUsingKeyPairFileContentInvalidKey() + { + var privateKey = AuthConnectionParameters.GetPriavteKeyContentForKeypairAuth("SNOWFLAKE_AUTH_TEST_INVALID_PRIVATE_KEY_PATH"); + var parameters = AuthConnectionParameters.GetKeyPairFromFileContentParameters(privateKey); + _connectionString = AuthConnectionParameters.SetPrivateKeyFromFileContentParameters(parameters); + + Console.WriteLine(_connectionString); + authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); + authTestHelper.verifyExceptionIsThrown("Error: JWT token is invalid"); + } + + //TO BE UNCOMMENTED + // [Test, Order(3)] + // public void TestAuthenticateUsingKeyPairFilePathSuccessful() + // { + // var privateKeyPath = AuthConnectionParameters.GetPriavteKeyPathForKeypairAuth("SNOWFLAKE_AUTH_TEST_PRIVATE_KEY_PATH"); + // var parameters = AuthConnectionParameters.GetKeyPairFromFilePathParameters(privateKeyPath); + // _connectionString = AuthConnectionParameters.SetPrivateKeyFromFilePathParameters(parameters); + // + // Console.WriteLine(_connectionString); + // authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); + // authTestHelper.verifyExceptionIsNotThrown(); + // } + + [Test, Order(4)] + public void TestAuthenticateUsingKeyPairFilePathInvalidKey() + { + var privateKeyPath = AuthConnectionParameters.GetPriavteKeyPathForKeypairAuth("SNOWFLAKE_AUTH_TEST_INVALID_PRIVATE_KEY_PATH"); + var parameters = AuthConnectionParameters.GetKeyPairFromFilePathParameters(privateKeyPath); + _connectionString = AuthConnectionParameters.SetPrivateKeyFromFilePathParameters(parameters); + + Console.WriteLine(_connectionString); + authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); + authTestHelper.verifyExceptionIsThrown("Error: JWT token is invalid"); + } + } +} diff --git a/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs new file mode 100644 index 000000000..9a94a61d8 --- /dev/null +++ b/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved. + */ + +using NUnit.Framework; + +namespace Snowflake.Data.Tests.AuthenticationTests +{ + [NonParallelizable] + public class OauthConnection : SFBaseTest + { + private string _connectionString = ""; + + AuthTestHelper authTestHelper = new AuthTestHelper(); + + [SetUp] + public void SetUp() + { + string token = AuthConnectionParameters.GetOauthToken(); + var parameters = AuthConnectionParameters.GetOauthConnectionParameters(token); + _connectionString = AuthConnectionParameters.SetOauthConnectionParameters(parameters); + + } + + [Test, Order(1)] + public void TestAuthenticateUsingOauthSuccessful() + { + authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); + authTestHelper.verifyExceptionIsNotThrown(); + } + + [Test, Order(2)] + public void TestAuthenticateUsingOauthInvalidToken() + { + string token = "invalidToken"; + var parameters = AuthConnectionParameters.GetOauthConnectionParameters(token); + _connectionString = AuthConnectionParameters.SetOauthConnectionParameters(parameters); + + + authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); + authTestHelper.verifyExceptionIsThrown("Invalid OAuth access token"); + } + + [Test, Order(3), Ignore("Skipped, waits for SNOW-1893041")] + public void TestAuthenticateUsingOauthMismatchedUser() + { + string token = AuthConnectionParameters.GetOauthToken(); + var parameters = AuthConnectionParameters.GetOauthConnectionParameters(token); + parameters["user"] = "fakeAccount"; + _connectionString = AuthConnectionParameters.SetOauthConnectionParameters(parameters) + ";poolingEnabled=false;minPoolSize=0;"; + authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); + authTestHelper.verifyExceptionIsThrown("The user you were trying to authenticate as differs from the user tied to the access token"); + + } + } +} diff --git a/Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs new file mode 100644 index 000000000..db8416c96 --- /dev/null +++ b/Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs @@ -0,0 +1,81 @@ +/* + * Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved. + */ + +using NUnit.Framework; + +namespace Snowflake.Data.Tests.AuthenticationTests +{ + [NonParallelizable] + public class OktaConnection : SFBaseTest + { + private string _connectionString = ""; + AuthTestHelper authTestHelper = new AuthTestHelper(); + + [SetUp] + public void SetUp() + { + var parameters = AuthConnectionParameters.GetOktaConnectionParameters(); + _connectionString = AuthConnectionParameters.SetOktaConnectionParameters(parameters); + authTestHelper.cleanBrowserProcess(); + + } + + [Test, Order(1)] + public void TestAuthenticateUsingOktaSuccessful() + { + authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); + authTestHelper.verifyExceptionIsNotThrown(); + + } + + [Test, Order(2)] + public void TestAuthenticateUsingOktaWrongUsernameParam() + { + var parameters = AuthConnectionParameters.GetOktaConnectionParameters(); + parameters["user"] = "differentUser"; + _connectionString = AuthConnectionParameters.SetOktaConnectionParameters(parameters); + + authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); + authTestHelper.verifyExceptionIsThrown("401 (Unauthorized)"); + } + + [Test, Order(3)] + public void TestAuthenticateUsingOktaWrongCredentials() + { + var parameters = AuthConnectionParameters.GetOktaConnectionParameters(); + parameters["user"] = "differentUser"; + parameters["password"] = "fakepassword"; + + _connectionString = AuthConnectionParameters.SetOktaConnectionParameters(parameters); + + authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); + authTestHelper.verifyExceptionIsThrown("401 (Unauthorized)"); + } + + [Test, Order(4)] + public void TestAuthenticateUsingOktaWrongUrl() + { + var parameters = AuthConnectionParameters.GetOktaConnectionParameters(); + parameters["authenticator"] = "https://invalid.okta.com/"; + + _connectionString = AuthConnectionParameters.SetOktaConnectionParameters(parameters); + + authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); + authTestHelper.verifyExceptionIsThrown("The specified authenticator is not accepted by your Snowflake account configuration"); + } + + + [Test, Order(5)] + public void TestAuthenticateUsingUrlWithoutOkta() + { + var parameters = AuthConnectionParameters.GetOktaConnectionParameters(); + parameters["authenticator"] = "https://invalid.abc.com/"; + + _connectionString = AuthConnectionParameters.SetOktaConnectionParameters(parameters); + + authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); + authTestHelper.verifyExceptionIsThrown("Unknown authenticator"); + } + } +} From 029a16d51959f60df500fa4922c6a272f790a7b8 Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Mon, 27 Jan 2025 13:13:30 +0100 Subject: [PATCH 02/41] after initial review --- Jenkinsfile | 24 ++- .../AuthConnectionParameters.cs | 181 ------------------ .../AuthConnectionString.cs | 162 ++++++++++++++++ .../AuthenticationTests/AuthTestHelper.cs | 43 +++-- .../ExternalBrowserConnection.cs | 81 ++++---- .../AuthenticationTests/KeyPairConnection.cs | 83 ++++---- .../AuthenticationTests/OauthConnection.cs | 44 +++-- .../AuthenticationTests/OktaConnection.cs | 69 ++++--- ci/container/test_authentication.sh | 15 ++ ci/test_authentication.sh | 31 +++ 10 files changed, 401 insertions(+), 332 deletions(-) delete mode 100644 Snowflake.Data.Tests/AuthenticationTests/AuthConnectionParameters.cs create mode 100644 Snowflake.Data.Tests/AuthenticationTests/AuthConnectionString.cs create mode 100755 ci/container/test_authentication.sh create mode 100755 ci/test_authentication.sh diff --git a/Jenkinsfile b/Jenkinsfile index 7cc65d526..13ec9265f 100644 --- a/Jenkinsfile +++ b/Jenkinsfile @@ -32,13 +32,29 @@ timestamps { string(name: 'parent_job', value: env.JOB_NAME), string(name: 'parent_build_number', value: env.BUILD_NUMBER) ] - stage('Test') { - build job: 'RT-LanguageDotnet-PC',parameters: params - } + parallel( + 'Test': { + stage('Test') { + build job: 'RT-LanguageGo-PC', parameters: params + } + }, + 'Test Authentication': { + stage('Test Authentication') { + withCredentials([ + string(credentialsId: 'a791118f-a1ea-46cd-b876-56da1b9bc71c', variable: 'NEXUS_PASSWORD'), + string(credentialsId: 'sfctest0-parameters-secret', variable: 'PARAMETERS_SECRET') + ]) { + sh '''\ + |#!/bin/bash -e + |$WORKSPACE/ci/test_authentication.sh + '''.stripMargin() + } + } + } + ) } } - pipeline { agent { label 'regular-memory-node' } options { timestamps() } diff --git a/Snowflake.Data.Tests/AuthenticationTests/AuthConnectionParameters.cs b/Snowflake.Data.Tests/AuthenticationTests/AuthConnectionParameters.cs deleted file mode 100644 index e75806294..000000000 --- a/Snowflake.Data.Tests/AuthenticationTests/AuthConnectionParameters.cs +++ /dev/null @@ -1,181 +0,0 @@ -using System; -using System.Collections.Generic; -using System.Net; -using System.Text; -using System.Collections.Specialized; -using Newtonsoft.Json.Linq; -using NUnit.Framework; -using System.IO; - -namespace Snowflake.Data.Tests.AuthenticationTests - -{ - static class AuthConnectionParameters - { - public static readonly string SsoUser = Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_BROWSER_USER"); - public static readonly string Host = Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_HOST"); - public static readonly string SsoPassword = Environment.GetEnvironmentVariable("SNOWFLAKE_TEST_OKTA_PASS"); - public static readonly string Okta = Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_OKTA_NAME"); - public static readonly string OauthPassword = Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_EXTERNAL_OAUTH_OKTA_USER_PASSWORD"); - public static Dictionary GetBaseConnectionParameters() - { - var properties = new Dictionary - { - { "host", Host }, - { "protocol", Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_PROTOCOL")}, - { "port", Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_PORT") }, - { "role", Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_ROLE") }, - { "account", Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_ACCOUNT") }, - { "db", Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_DATABASE") }, - { "schema", Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_SCHEMA") }, - { "warehouse", Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_WAREHOUSE") }, - }; - return properties; - } - - public static String SetBaseConnectionParameters(Dictionary param) - { - var basicConfig = String.Format("host={0};port={1};account={2};role={3};db={4};schema={5};warehouse={6};", - param["host"], param["port"], param["account"], param["role"], param["db"], param["schema"], param["warehouse"]); - return basicConfig; - } - - public static Dictionary GetExternalBrowserConnectionParameters() - { - var properties = GetBaseConnectionParameters(); - properties.Add("authenticator", "externalbrowser"); - properties.Add("user", Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_BROWSER_USER")); - // properties.Add("user", SsoUser); - return properties; - } - - public static String SetExternalBrowserConnectionParameters(Dictionary param) - { - var config = String.Format("{0}authenticator={1};user={2};", SetBaseConnectionParameters(param), param["authenticator"], param["user"]); - return config; - } - - public static Dictionary GetOauthConnectionParameters(string token) - { - var properties = GetBaseConnectionParameters(); - properties.Add("authenticator", "OAUTH"); - properties.Add("user", SsoUser); - properties.Add("token", token); - return properties; - } - - public static String SetOauthConnectionParameters(Dictionary param) - { - var config = String.Format("{0}authenticator={1};user={2};token={3}", SetBaseConnectionParameters(param), param["authenticator"], param["user"], param["token"]); - return config; - } - - public static Dictionary GetStoreIdTokenConnectionParameters(string token) - { - var properties = GetExternalBrowserConnectionParameters(); - properties.Add("CLIENT_STORE_TEMPORARY_CREDENTIAL", "true"); - return properties; - } - - public static Dictionary GetOktaConnectionParameters() - { - var properties = GetBaseConnectionParameters(); - properties.Add("authenticator", Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_OAUTH_URL")); - properties.Add("user", SsoUser); - properties.Add("password", SsoPassword); - - return properties; - } - - public static Dictionary GetKeyPairFromFileContentParameters(String privateKey) - { - - var properties = GetBaseConnectionParameters(); - properties.Add("authenticator", "snowflake_jwt"); - properties.Add("user", SsoUser); - - properties.Add("private_key", privateKey); - - return properties; - } - - - public static Dictionary GetKeyPairFromFilePathParameters(String privateKeyPath) - { - - var properties = GetBaseConnectionParameters(); - properties.Add("authenticator", "snowflake_jwt"); - properties.Add("user", AuthConnectionParameters.SsoUser); - properties.Add("private_key_file", privateKeyPath); - return properties; - } - public static String SetPrivateKeyFromFileContentParameters(Dictionary param) - { - var config = String.Format("{0}authenticator={1};private_key={2};user={3}", SetBaseConnectionParameters(param), param["authenticator"], param["private_key"], SsoUser); - return config; - } - - public static String SetPrivateKeyFromFilePathParameters(Dictionary param) - { - var config = String.Format("{0}authenticator={1};private_key_file={2};user={3}", SetBaseConnectionParameters(param),param["authenticator"], param["private_key_file"], SsoUser); - return config; - } - - public static String SetOktaConnectionParameters(Dictionary param) - { - var config = String.Format("{0}authenticator={1};user={2};password={3}", SetBaseConnectionParameters(param), param["authenticator"], param["user"], param["password"]); - return config; - } - - public static string GetPriavteKeyContentForKeypairAuth(string envName) - { - string filePath = Environment.GetEnvironmentVariable(envName); - Assert.IsNotNull(filePath); - string pemKey = File.ReadAllText("../../../../" + filePath); - Assert.IsNotNull(pemKey, $"Failed to read file: {filePath}"); - return pemKey; - - } - - public static string GetPriavteKeyPathForKeypairAuth(string envName) - { - string filePath = Environment.GetEnvironmentVariable(envName); - Assert.IsNotNull(filePath); - return Path.Combine("../../../../", filePath); - } - - public static string GetOauthToken() - { - try - { - using (var client = new WebClient()) - { - var values = new NameValueCollection(); - var authUrl = Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_OAUTH_URL"); - var clientId = Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_OAUTH_CLIENT_ID"); - var clientSecret = Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_OAUTH_CLIENT_SECRET"); - var credentials = Convert.ToBase64String(Encoding.ASCII.GetBytes($"{clientId}:{clientSecret}")); - - client.Headers[HttpRequestHeader.Authorization] = "Basic " + credentials; - - values["username"] = Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_OKTA_USER"); - values["password"] = Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_OKTA_PASS"); - values["grant_type"] = "password"; - values["scope"] = "session:role:" + Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_ROLE"); - - var fullResponse = Encoding.Default.GetString(client.UploadValues(authUrl, values)); - var responseString = JObject.Parse(fullResponse); - Assert.IsNotNull(responseString["access_token"]); - Console.WriteLine(responseString.ToString()); - return responseString["access_token"].ToString(); - } - } - catch (Exception e) - { - Console.WriteLine(e.Message); - return null; - } - - } - } -} diff --git a/Snowflake.Data.Tests/AuthenticationTests/AuthConnectionString.cs b/Snowflake.Data.Tests/AuthenticationTests/AuthConnectionString.cs new file mode 100644 index 000000000..459b0a293 --- /dev/null +++ b/Snowflake.Data.Tests/AuthenticationTests/AuthConnectionString.cs @@ -0,0 +1,162 @@ +using System; +using System.Collections.Generic; +using System.Text; +using Newtonsoft.Json.Linq; +using NUnit.Framework; +using System.IO; +using Snowflake.Data.Core; +using System.Net.Http; + +namespace Snowflake.Data.Tests.AuthenticationTests + +{ + static class AuthConnectionString + { + public static readonly string SsoUser = Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_BROWSER_USER"); + public static readonly string Host = Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_HOST"); + public static readonly string SsoPassword = Environment.GetEnvironmentVariable("SNOWFLAKE_TEST_OKTA_PASS"); + + public static SFSessionProperties GetBaseConnectionString() + { + var properties = new SFSessionProperties() + { + {SFSessionProperty.HOST, Host }, + {SFSessionProperty.PORT, Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_PORT") }, + {SFSessionProperty.ROLE, Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_ROLE") }, + {SFSessionProperty.ACCOUNT, Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_ACCOUNT") }, + {SFSessionProperty.DB, Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_DATABASE") }, + {SFSessionProperty.SCHEMA, Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_SCHEMA") }, + {SFSessionProperty.WAREHOUSE, Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_WAREHOUSE") }, + }; + return properties; + } + + public static string SetBaseConnectionString(SFSessionProperties parameters) => + $"host={parameters[SFSessionProperty.HOST]};port={parameters[SFSessionProperty.PORT]};account={parameters[SFSessionProperty.ACCOUNT]};role={parameters[SFSessionProperty.ROLE]};db={parameters[SFSessionProperty.DB]};schema={parameters[SFSessionProperty.SCHEMA]};warehouse={parameters[SFSessionProperty.WAREHOUSE]};"; + + + public static SFSessionProperties GetExternalBrowserConnectionString() + { + var properties = GetBaseConnectionString(); + properties.Add(SFSessionProperty.AUTHENTICATOR, "externalbrowser"); + properties.Add(SFSessionProperty.USER, Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_BROWSER_USER")); + return properties; + } + + public static string SetExternalBrowserConnectionString(SFSessionProperties parameters) => + $"{SetBaseConnectionString(parameters)}authenticator={parameters[SFSessionProperty.AUTHENTICATOR]};user={parameters[SFSessionProperty.USER]};"; + + + public static SFSessionProperties GetOauthConnectionString(string token) + { + var properties = GetBaseConnectionString(); + properties.Add(SFSessionProperty.AUTHENTICATOR, "OAUTH"); + properties.Add(SFSessionProperty.USER, SsoUser); + properties.Add(SFSessionProperty.TOKEN, token); + return properties; + } + + public static string SetOauthConnectionString(SFSessionProperties parameters) => + $"{SetBaseConnectionString(parameters)}authenticator={parameters[SFSessionProperty.AUTHENTICATOR]};user={parameters[SFSessionProperty.USER]};token={parameters[SFSessionProperty.TOKEN]};"; + + public static SFSessionProperties GetOktaConnectionString() + { + var properties = GetBaseConnectionString(); + properties.Add(SFSessionProperty.AUTHENTICATOR, Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_OAUTH_URL")); + properties.Add(SFSessionProperty.USER, SsoUser); + properties.Add(SFSessionProperty.PASSWORD, SsoPassword); + + return properties; + } + + public static SFSessionProperties GetKeyPairFromFileContentParameters(string privateKey) + { + + var properties = GetBaseConnectionString(); + properties.Add(SFSessionProperty.AUTHENTICATOR, "snowflake_jwt"); + properties.Add(SFSessionProperty.USER, SsoUser); + properties.Add(SFSessionProperty.PRIVATE_KEY, privateKey); + + return properties; + } + + + public static SFSessionProperties GetKeyPairFromFilePathConnectionString(string privateKeyPath) + { + + var properties = GetBaseConnectionString(); + properties.Add(SFSessionProperty.AUTHENTICATOR, "snowflake_jwt"); + properties.Add(SFSessionProperty.USER, AuthConnectionString.SsoUser); + properties.Add(SFSessionProperty.PRIVATE_KEY_FILE, privateKeyPath); + return properties; + } + public static string SetPrivateKeyFromFileContentConnectionString(SFSessionProperties parameters) => + $"{SetBaseConnectionString(parameters)}authenticator={parameters[SFSessionProperty.AUTHENTICATOR]};private_key={parameters[SFSessionProperty.PRIVATE_KEY]};user={SsoUser}"; + + + public static string SetPrivateKeyFromFilePathConnectionString(SFSessionProperties parameters) => + $"{SetBaseConnectionString(parameters)}authenticator={parameters[SFSessionProperty.AUTHENTICATOR]};private_key_file={parameters[SFSessionProperty.PRIVATE_KEY_FILE]};user={SsoUser}"; + + + public static string SetOktaConnectionString(SFSessionProperties parameters) => + $"{SetBaseConnectionString(parameters)}authenticator={parameters[SFSessionProperty.AUTHENTICATOR]};user={parameters[SFSessionProperty.USER]};password={parameters[SFSessionProperty.PASSWORD]};"; + + + public static string GetPrivateKeyContentForKeypairAuth(string fileLocation) + { + string filePath = Environment.GetEnvironmentVariable(fileLocation); + Assert.IsNotNull(filePath); + string pemKey = File.ReadAllText(Path.Combine("..", "..", "..", "..", filePath)); + Assert.IsNotNull(pemKey, $"Failed to read file: {filePath}"); + return pemKey; + + } + + public static string GetPrivateKeyPathForKeypairAuth(string fileLocation) + { + string filePath = Environment.GetEnvironmentVariable(fileLocation); + Assert.IsNotNull(filePath); + return Path.Combine("..", "..", "..", "..", filePath); + } + + public static string GetOauthToken() + { + try + { + + using (var client = new HttpClient()) + { + var authUrl = Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_OAUTH_URL"); + var clientId = Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_OAUTH_CLIENT_ID"); + var clientSecret = Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_OAUTH_CLIENT_SECRET"); + var credentials = Convert.ToBase64String(Encoding.ASCII.GetBytes($"{clientId}:{clientSecret}")); + + client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", credentials); + + var values = new Dictionary + { + { "username", Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_OKTA_USER") }, + { "password", Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_OKTA_PASS") }, + { "grant_type", "password" }, + { "scope", "session:role:" + Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_ROLE") } + }; + + var content = new FormUrlEncodedContent(values); + var response = client.PostAsync(authUrl, content).Result; + response.EnsureSuccessStatusCode(); + + var fullResponse = response.Content.ReadAsStringAsync().Result; + var responseObject = JObject.Parse(fullResponse); + Assert.IsNotNull(responseObject["access_token"]); + return responseObject["access_token"].ToString(); + } + } + catch (Exception e) + { + Assert.Fail($"Failed to get OAuth token: {e.Message}"); + return null; + } + + } + } +} diff --git a/Snowflake.Data.Tests/AuthenticationTests/AuthTestHelper.cs b/Snowflake.Data.Tests/AuthenticationTests/AuthTestHelper.cs index 335e49620..94660dc10 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/AuthTestHelper.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/AuthTestHelper.cs @@ -4,24 +4,29 @@ using System.Data; using NUnit.Framework; using Snowflake.Data.Client; +using Snowflake.Data.Log; + namespace Snowflake.Data.Tests.AuthenticationTests { + public class AuthTestHelper { + private static readonly SFLogger s_logger = SFLoggerFactory.GetLogger(); + private Exception _exception; - private readonly bool runAuthTestsManually; + private readonly bool _runAuthTestsManually; public AuthTestHelper() { string envVar = Environment.GetEnvironmentVariable("RUN_AUTH_TESTS_MANUALLY"); - runAuthTestsManually = string.IsNullOrEmpty(envVar) ? true : bool.Parse(envVar); + _runAuthTestsManually = bool.Parse(envVar ?? "true"); } - public void ProvideCredentials(string scenario, string login, string password) + private void ProvideCredentials(string scenario, string login, string password) { try { - String provideBrowserCredentialsPath = "/externalbrowser/provideBrowserCredentials.js"; + string provideBrowserCredentialsPath = "/externalbrowser/provideBrowserCredentials.js"; var startInfo = new ProcessStartInfo { @@ -44,8 +49,8 @@ public void ProvideCredentials(string scenario, string login, string password) string output = process.StandardOutput.ReadToEnd(); string error = process.StandardError.ReadToEnd(); - Console.WriteLine("Output: " + output); - Console.WriteLine("Error: " + error); + s_logger.Info("Output: " + output); + s_logger.Info("Error: " + error); } } catch (Exception e) @@ -54,9 +59,10 @@ public void ProvideCredentials(string scenario, string login, string password) } } - public void cleanBrowserProcess() + public void CleanBrowserProcess() { - if (!runAuthTestsManually) + if (_runAuthTestsManually) + return; { try { string cleanBrowserProcessesPath = "/externalbrowser/cleanBrowserProcesses.js"; @@ -72,7 +78,7 @@ public void cleanBrowserProcess() using (var process = new Process { StartInfo = startInfo }) { process.Start(); - if (!process.WaitForExit(20000)) // Wait for 15 seconds + if (!process.WaitForExit(20000)) // Wait for 20 seconds { process.Kill(); throw new TimeoutException("The process did not complete in the allotted time."); @@ -80,8 +86,8 @@ public void cleanBrowserProcess() string output = process.StandardOutput.ReadToEnd(); string error = process.StandardError.ReadToEnd(); - Console.WriteLine("Output: " + output); - Console.WriteLine("Error: " + error); + s_logger.Info("Output: " + output); + s_logger.Info("Error: " + error); } } catch (Exception e) @@ -107,8 +113,8 @@ public void ConnectAndExecuteSimpleQuery(string connectionString) { command.CommandText = "SELECT 1"; var result = command.ExecuteScalar(); - Console.WriteLine(result.ToString()); Assert.AreEqual("1", result.ToString()); + s_logger.Info(result.ToString()); } } } @@ -118,29 +124,29 @@ public void ConnectAndExecuteSimpleQuery(string connectionString) } } - public Thread getConnectAndExecuteSimpleQueryThread(string parameters) + public Thread GetConnectAndExecuteSimpleQueryThread(string parameters) { return new Thread(() => ConnectAndExecuteSimpleQuery(parameters)); } - public Thread getProvideCredentialsThread(string scenario, string login, string password) + public Thread GetProvideCredentialsThread(string scenario, string login, string password) { return new Thread(() => ProvideCredentials(scenario, login, password)); } - public void verifyExceptionIsNotThrown() { + public void VerifyExceptionIsNotThrown() { Assert.That(_exception, Is.Null, "Unexpected exception thrown"); } - public void verifyExceptionIsThrown(string error) { + public void VerifyExceptionIsThrown(string error) { Assert.That(_exception, Is.Not.Null, "Expected exception was not thrown"); Assert.That(_exception.Message, Does.Contain(error), "Unexpected exception message."); } - public void connectAndProvideCredentials(Thread provideCredentialsThread, Thread connectThread) + public void ConnectAndProvideCredentials(Thread provideCredentialsThread, Thread connectThread) { - if (runAuthTestsManually) + if (_runAuthTestsManually) { connectThread.Start(); connectThread.Join(); @@ -152,7 +158,6 @@ public void connectAndProvideCredentials(Thread provideCredentialsThread, Thread provideCredentialsThread.Join(); connectThread.Join(); } - } } } diff --git a/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs index 14ee9db40..c050f5f5f 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs @@ -4,87 +4,96 @@ using System.Threading; using NUnit.Framework; +using Snowflake.Data.Core; namespace Snowflake.Data.Tests.AuthenticationTests { + [NonParallelizable] - public class ExternalBrowserConnection : SFBaseTest + public class ExternalBrowserConnectionTest : SFBaseTest { private string _connectionString = ""; - string _login = AuthConnectionParameters.SsoUser; - string _password = AuthConnectionParameters.SsoPassword; - AuthTestHelper authTestHelper = new AuthTestHelper(); + private string _login = AuthConnectionString.SsoUser; + private string _password = AuthConnectionString.SsoPassword; [SetUp] public void SetUp() { - _login = AuthConnectionParameters.SsoUser; - _password = AuthConnectionParameters.SsoPassword; - authTestHelper.cleanBrowserProcess(); - var parameters = AuthConnectionParameters.GetExternalBrowserConnectionParameters(); - _connectionString = AuthConnectionParameters.SetExternalBrowserConnectionParameters(parameters); + AuthTestHelper authTestHelper = new AuthTestHelper(); + _login = AuthConnectionString.SsoUser; + _password = AuthConnectionString.SsoPassword; + authTestHelper.CleanBrowserProcess(); + var parameters = AuthConnectionString.GetExternalBrowserConnectionString(); + _connectionString = AuthConnectionString.SetExternalBrowserConnectionString(parameters); } - [Test, Order(1)] + [Test, IgnoreOnCI] public void TestAuthenticateUsingExternalBrowserSuccessful() { + AuthTestHelper authTestHelper = new AuthTestHelper(); - Thread connectThread = authTestHelper.getConnectAndExecuteSimpleQueryThread(_connectionString); - Thread provideCredentialsThread = authTestHelper.getProvideCredentialsThread("success", _login, _password); + Thread connectThread = authTestHelper.GetConnectAndExecuteSimpleQueryThread(_connectionString); + Thread provideCredentialsThread = authTestHelper.GetProvideCredentialsThread("success", _login, _password); - authTestHelper.connectAndProvideCredentials(provideCredentialsThread, connectThread); - authTestHelper.verifyExceptionIsNotThrown(); + authTestHelper.ConnectAndProvideCredentials(provideCredentialsThread, connectThread); + authTestHelper.VerifyExceptionIsNotThrown(); } - [Test, Order(2)] + [Test, IgnoreOnCI] public void TestAuthenticateUsingExternalBrowserMismatchedUser() { - var parameters = AuthConnectionParameters.GetExternalBrowserConnectionParameters(); + AuthTestHelper authTestHelper = new AuthTestHelper(); - parameters["user"] = "differentUser"; - _connectionString = AuthConnectionParameters.SetExternalBrowserConnectionParameters(parameters); + var parameters = AuthConnectionString.GetExternalBrowserConnectionString(); + parameters[SFSessionProperty.USER] = "differentUser"; - Thread connectThread = authTestHelper.getConnectAndExecuteSimpleQueryThread(_connectionString); - Thread provideCredentialsThread = authTestHelper.getProvideCredentialsThread("success", _login, _password); + _connectionString = AuthConnectionString.SetExternalBrowserConnectionString(parameters); - authTestHelper.connectAndProvideCredentials(provideCredentialsThread, connectThread); - authTestHelper.verifyExceptionIsThrown("The user you were trying to authenticate as differs from the user currently logged in at the IDP"); + Thread connectThread = authTestHelper.GetConnectAndExecuteSimpleQueryThread(_connectionString); + Thread provideCredentialsThread = authTestHelper.GetProvideCredentialsThread("success", _login, _password); + + authTestHelper.ConnectAndProvideCredentials(provideCredentialsThread, connectThread); + authTestHelper.VerifyExceptionIsThrown("The user you were trying to authenticate as differs from the user currently logged in at the IDP"); } - [Test, Order(3)] + [Test, IgnoreOnCI] public void TestAuthenticateUsingExternalBrowserWrongCredentials() { - var parameters = AuthConnectionParameters.GetExternalBrowserConnectionParameters(); + AuthTestHelper authTestHelper = new AuthTestHelper(); - _connectionString = AuthConnectionParameters.SetExternalBrowserConnectionParameters(parameters); + var parameters = AuthConnectionString.GetExternalBrowserConnectionString(); + + _connectionString = AuthConnectionString.SetExternalBrowserConnectionString(parameters); _connectionString += "BROWSER_RESPONSE_TIMEOUT=15;"; _login = "itsnotanaccount.com"; _password = "fakepassword"; - Thread connectThread = authTestHelper.getConnectAndExecuteSimpleQueryThread(_connectionString); - Thread provideCredentialsThread = authTestHelper.getProvideCredentialsThread("fail", _login, _password); + Thread connectThread = authTestHelper.GetConnectAndExecuteSimpleQueryThread(_connectionString); + Thread provideCredentialsThread = authTestHelper.GetProvideCredentialsThread("fail", _login, _password); - authTestHelper.connectAndProvideCredentials(provideCredentialsThread, connectThread); - authTestHelper.verifyExceptionIsThrown("Browser response timed out after 15 seconds"); + authTestHelper.ConnectAndProvideCredentials(provideCredentialsThread, connectThread); + authTestHelper.VerifyExceptionIsThrown("Browser response timed out after 15 seconds"); } - [Test, Order(4)] + [Test, IgnoreOnCI] public void TestAuthenticateUsingExternalBrowserTimeout() { - var parameters = AuthConnectionParameters.GetExternalBrowserConnectionParameters(); + AuthTestHelper authTestHelper = new AuthTestHelper(); + + var parameters = AuthConnectionString.GetExternalBrowserConnectionString(); - _connectionString = AuthConnectionParameters.SetExternalBrowserConnectionParameters(parameters); + _connectionString = AuthConnectionString.SetExternalBrowserConnectionString(parameters); _connectionString += "BROWSER_RESPONSE_TIMEOUT=1;"; - Thread connectThread = authTestHelper.getConnectAndExecuteSimpleQueryThread(_connectionString); - Thread provideCredentialsThread = authTestHelper.getProvideCredentialsThread("timeout", _login, _password); + Thread connectThread = authTestHelper.GetConnectAndExecuteSimpleQueryThread(_connectionString); + Thread provideCredentialsThread = authTestHelper.GetProvideCredentialsThread("timeout", _login, _password); - authTestHelper.connectAndProvideCredentials(provideCredentialsThread, connectThread); - authTestHelper.verifyExceptionIsThrown("Browser response timed out after 1 seconds"); + authTestHelper.ConnectAndProvideCredentials(provideCredentialsThread, connectThread); + authTestHelper.VerifyExceptionIsThrown("Browser response timed out after 1 seconds"); } } } diff --git a/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs index 7d7d8c2fd..f71c455dc 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs @@ -2,76 +2,69 @@ * Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved. */ -using System; - using NUnit.Framework; namespace Snowflake.Data.Tests.AuthenticationTests { + [NonParallelizable] - public class KeyPairConnection : SFBaseTest + public class KeyPairConnectionTest : SFBaseTest { private string _connectionString = ""; - AuthTestHelper authTestHelper = new AuthTestHelper(); - [SetUp] - public void SetUp() - { + [Test, IgnoreOnCI] + public void TestAuthenticateUsingKeyPairFilcContentSuccessful() + { + AuthTestHelper authTestHelper = new AuthTestHelper(); + var privateKey = AuthConnectionString.GetPrivateKeyContentForKeypairAuth("SNOWFLAKE_AUTH_TEST_PRIVATE_KEY_PATH"); + var parameters = AuthConnectionString.GetKeyPairFromFileContentParameters(privateKey); + _connectionString = AuthConnectionString.SetPrivateKeyFromFileContentConnectionString(parameters); + authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); + authTestHelper.VerifyExceptionIsNotThrown(); } - //TO BE UNCOMMENTED - // [Test, Order(1)] - // public void TestAuthenticateUsingKeyPairFilcContentSuccessful() - // { - // var privateKey = AuthConnectionParameters.GetPriavteKeyContentForKeypairAuth("SNOWFLAKE_AUTH_TEST_PRIVATE_KEY_PATH"); - // var parameters = AuthConnectionParameters.GetKeyPairFromFileContentParameters(privateKey); - // _connectionString = AuthConnectionParameters.SetPrivateKeyFromFileContentParameters(parameters); - // - // Console.WriteLine(_connectionString); - // authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); - // authTestHelper.verifyExceptionIsNotThrown(); - // } - - [Test, Order(2)] + [Test, IgnoreOnCI] public void TestAuthenticateUsingKeyPairFileContentInvalidKey() { - var privateKey = AuthConnectionParameters.GetPriavteKeyContentForKeypairAuth("SNOWFLAKE_AUTH_TEST_INVALID_PRIVATE_KEY_PATH"); - var parameters = AuthConnectionParameters.GetKeyPairFromFileContentParameters(privateKey); - _connectionString = AuthConnectionParameters.SetPrivateKeyFromFileContentParameters(parameters); + AuthTestHelper authTestHelper = new AuthTestHelper(); + + var privateKey = AuthConnectionString.GetPrivateKeyContentForKeypairAuth("SNOWFLAKE_AUTH_TEST_INVALID_PRIVATE_KEY_PATH"); + var parameters = AuthConnectionString.GetKeyPairFromFileContentParameters(privateKey); + _connectionString = AuthConnectionString.SetPrivateKeyFromFileContentConnectionString(parameters); - Console.WriteLine(_connectionString); authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); - authTestHelper.verifyExceptionIsThrown("Error: JWT token is invalid"); + authTestHelper.VerifyExceptionIsThrown("Error: JWT token is invalid"); } - //TO BE UNCOMMENTED - // [Test, Order(3)] - // public void TestAuthenticateUsingKeyPairFilePathSuccessful() - // { - // var privateKeyPath = AuthConnectionParameters.GetPriavteKeyPathForKeypairAuth("SNOWFLAKE_AUTH_TEST_PRIVATE_KEY_PATH"); - // var parameters = AuthConnectionParameters.GetKeyPairFromFilePathParameters(privateKeyPath); - // _connectionString = AuthConnectionParameters.SetPrivateKeyFromFilePathParameters(parameters); - // - // Console.WriteLine(_connectionString); - // authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); - // authTestHelper.verifyExceptionIsNotThrown(); - // } - - [Test, Order(4)] + [Test, IgnoreOnCI] + public void TestAuthenticateUsingKeyPairFilePathSuccessful() + { + AuthTestHelper authTestHelper = new AuthTestHelper(); + + var privateKeyPath = AuthConnectionString.GetPrivateKeyPathForKeypairAuth("SNOWFLAKE_AUTH_TEST_PRIVATE_KEY_PATH"); + var parameters = AuthConnectionString.GetKeyPairFromFilePathConnectionString(privateKeyPath); + _connectionString = AuthConnectionString.SetPrivateKeyFromFilePathConnectionString(parameters); + + authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); + authTestHelper.VerifyExceptionIsNotThrown(); + } + + [Test, IgnoreOnCI] public void TestAuthenticateUsingKeyPairFilePathInvalidKey() { - var privateKeyPath = AuthConnectionParameters.GetPriavteKeyPathForKeypairAuth("SNOWFLAKE_AUTH_TEST_INVALID_PRIVATE_KEY_PATH"); - var parameters = AuthConnectionParameters.GetKeyPairFromFilePathParameters(privateKeyPath); - _connectionString = AuthConnectionParameters.SetPrivateKeyFromFilePathParameters(parameters); + AuthTestHelper authTestHelper = new AuthTestHelper(); + + var privateKeyPath = AuthConnectionString.GetPrivateKeyPathForKeypairAuth("SNOWFLAKE_AUTH_TEST_INVALID_PRIVATE_KEY_PATH"); + var parameters = AuthConnectionString.GetKeyPairFromFilePathConnectionString(privateKeyPath); + _connectionString = AuthConnectionString.SetPrivateKeyFromFilePathConnectionString(parameters); - Console.WriteLine(_connectionString); authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); - authTestHelper.verifyExceptionIsThrown("Error: JWT token is invalid"); + authTestHelper.VerifyExceptionIsThrown("Error: JWT token is invalid"); } } } diff --git a/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs index 9a94a61d8..e3094fd61 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs @@ -3,53 +3,59 @@ */ using NUnit.Framework; +using Snowflake.Data.Core; namespace Snowflake.Data.Tests.AuthenticationTests { + [NonParallelizable] - public class OauthConnection : SFBaseTest + public class OauthConnectionTest : SFBaseTest { private string _connectionString = ""; - AuthTestHelper authTestHelper = new AuthTestHelper(); - [SetUp] public void SetUp() { - string token = AuthConnectionParameters.GetOauthToken(); - var parameters = AuthConnectionParameters.GetOauthConnectionParameters(token); - _connectionString = AuthConnectionParameters.SetOauthConnectionParameters(parameters); + string token = AuthConnectionString.GetOauthToken(); + var parameters = AuthConnectionString.GetOauthConnectionString(token); + _connectionString = AuthConnectionString.SetOauthConnectionString(parameters); } - [Test, Order(1)] + [Test, IgnoreOnCI] public void TestAuthenticateUsingOauthSuccessful() { + AuthTestHelper authTestHelper = new AuthTestHelper(); + authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); - authTestHelper.verifyExceptionIsNotThrown(); + authTestHelper.VerifyExceptionIsNotThrown(); } - [Test, Order(2)] + [Test, IgnoreOnCI] public void TestAuthenticateUsingOauthInvalidToken() { - string token = "invalidToken"; - var parameters = AuthConnectionParameters.GetOauthConnectionParameters(token); - _connectionString = AuthConnectionParameters.SetOauthConnectionParameters(parameters); + AuthTestHelper authTestHelper = new AuthTestHelper(); + string token = "invalidToken"; + var parameters = AuthConnectionString.GetOauthConnectionString(token); + _connectionString = AuthConnectionString.SetOauthConnectionString(parameters); authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); - authTestHelper.verifyExceptionIsThrown("Invalid OAuth access token"); + authTestHelper.VerifyExceptionIsThrown("Invalid OAuth access token"); } - [Test, Order(3), Ignore("Skipped, waits for SNOW-1893041")] + [Test, Ignore("Skipped, waits for SNOW-1893041"), IgnoreOnCI] public void TestAuthenticateUsingOauthMismatchedUser() { - string token = AuthConnectionParameters.GetOauthToken(); - var parameters = AuthConnectionParameters.GetOauthConnectionParameters(token); - parameters["user"] = "fakeAccount"; - _connectionString = AuthConnectionParameters.SetOauthConnectionParameters(parameters) + ";poolingEnabled=false;minPoolSize=0;"; + AuthTestHelper authTestHelper = new AuthTestHelper(); + + string token = AuthConnectionString.GetOauthToken(); + var parameters = AuthConnectionString.GetOauthConnectionString(token); + parameters[SFSessionProperty.USER] = "fakeAccount"; + _connectionString = AuthConnectionString.SetOauthConnectionString(parameters) + ";poolingEnabled=false;minPoolSize=0;"; + authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); - authTestHelper.verifyExceptionIsThrown("The user you were trying to authenticate as differs from the user tied to the access token"); + authTestHelper.VerifyExceptionIsThrown("The user you were trying to authenticate as differs from the user tied to the access token"); } } diff --git a/Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs index db8416c96..68718061c 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs @@ -3,79 +3,92 @@ */ using NUnit.Framework; +using Snowflake.Data.Core; namespace Snowflake.Data.Tests.AuthenticationTests { + [NonParallelizable] - public class OktaConnection : SFBaseTest + public class OktaConnectionTest : SFBaseTest { private string _connectionString = ""; - AuthTestHelper authTestHelper = new AuthTestHelper(); [SetUp] public void SetUp() { - var parameters = AuthConnectionParameters.GetOktaConnectionParameters(); - _connectionString = AuthConnectionParameters.SetOktaConnectionParameters(parameters); - authTestHelper.cleanBrowserProcess(); + AuthTestHelper authTestHelper = new AuthTestHelper(); + + var parameters = AuthConnectionString.GetOktaConnectionString(); + _connectionString = AuthConnectionString.SetOktaConnectionString(parameters); + authTestHelper.CleanBrowserProcess(); } - [Test, Order(1)] + [Test, IgnoreOnCI] public void TestAuthenticateUsingOktaSuccessful() { + AuthTestHelper authTestHelper = new AuthTestHelper(); + authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); - authTestHelper.verifyExceptionIsNotThrown(); + authTestHelper.VerifyExceptionIsNotThrown(); } - [Test, Order(2)] + [Test, IgnoreOnCI] public void TestAuthenticateUsingOktaWrongUsernameParam() { - var parameters = AuthConnectionParameters.GetOktaConnectionParameters(); - parameters["user"] = "differentUser"; - _connectionString = AuthConnectionParameters.SetOktaConnectionParameters(parameters); + AuthTestHelper authTestHelper = new AuthTestHelper(); + + var parameters = AuthConnectionString.GetOktaConnectionString(); + parameters[SFSessionProperty.USER] = "differentUser"; + _connectionString = AuthConnectionString.SetOktaConnectionString(parameters); authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); - authTestHelper.verifyExceptionIsThrown("401 (Unauthorized)"); + authTestHelper.VerifyExceptionIsThrown("401 (Unauthorized)"); } - [Test, Order(3)] + [Test, IgnoreOnCI] public void TestAuthenticateUsingOktaWrongCredentials() { - var parameters = AuthConnectionParameters.GetOktaConnectionParameters(); - parameters["user"] = "differentUser"; - parameters["password"] = "fakepassword"; + AuthTestHelper authTestHelper = new AuthTestHelper(); - _connectionString = AuthConnectionParameters.SetOktaConnectionParameters(parameters); + var parameters = AuthConnectionString.GetOktaConnectionString(); + parameters[SFSessionProperty.USER] = "differentUser"; + parameters[SFSessionProperty.PASSWORD] = "fakepassword"; + + _connectionString = AuthConnectionString.SetOktaConnectionString(parameters); authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); - authTestHelper.verifyExceptionIsThrown("401 (Unauthorized)"); + authTestHelper.VerifyExceptionIsThrown("401 (Unauthorized)"); } - [Test, Order(4)] + [Test, IgnoreOnCI] public void TestAuthenticateUsingOktaWrongUrl() { - var parameters = AuthConnectionParameters.GetOktaConnectionParameters(); - parameters["authenticator"] = "https://invalid.okta.com/"; + AuthTestHelper authTestHelper = new AuthTestHelper(); + + var parameters = AuthConnectionString.GetOktaConnectionString(); + parameters[SFSessionProperty.AUTHENTICATOR] = "https://invalid.okta.com/"; - _connectionString = AuthConnectionParameters.SetOktaConnectionParameters(parameters); + _connectionString = AuthConnectionString.SetOktaConnectionString(parameters); authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); - authTestHelper.verifyExceptionIsThrown("The specified authenticator is not accepted by your Snowflake account configuration"); + authTestHelper.VerifyExceptionIsThrown("The specified authenticator is not accepted by your Snowflake account configuration"); } - [Test, Order(5)] + [Test, IgnoreOnCI] public void TestAuthenticateUsingUrlWithoutOkta() { - var parameters = AuthConnectionParameters.GetOktaConnectionParameters(); - parameters["authenticator"] = "https://invalid.abc.com/"; + AuthTestHelper authTestHelper = new AuthTestHelper(); + + var parameters = AuthConnectionString.GetOktaConnectionString(); + parameters[SFSessionProperty.AUTHENTICATOR] = "https://invalid.abc.com/"; - _connectionString = AuthConnectionParameters.SetOktaConnectionParameters(parameters); + _connectionString = AuthConnectionString.SetOktaConnectionString(parameters); authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); - authTestHelper.verifyExceptionIsThrown("Unknown authenticator"); + authTestHelper.VerifyExceptionIsThrown("Unknown authenticator"); } } } diff --git a/ci/container/test_authentication.sh b/ci/container/test_authentication.sh new file mode 100755 index 000000000..26d0b586b --- /dev/null +++ b/ci/container/test_authentication.sh @@ -0,0 +1,15 @@ +#!/bin/bash -e + + +set -o pipefail + +export WORKSPACE=${WORKSPACE:-/mnt/workspace} +export SOURCE_ROOT=${SOURCE_ROOT:-/mnt/host} + +AUTH_PARAMETER_FILE=./.github/workflows/parameters/parameters_aws_auth_tests.json +eval $(jq -r '.authtestparams | to_entries | map("export \(.key)=\(.value|tostring)")|.[]' $AUTH_PARAMETER_FILE) + +export SNOWFLAKE_AUTH_TEST_PRIVATE_KEY_PATH=./.github/workflows/parameters/rsa_keys/rsa_key.p8 +export SNOWFLAKE_AUTH_TEST_INVALID_PRIVATE_KEY_PATH=./.github/workflows/parameters/rsa_keys/rsa_key_invalid.p8 + +dotnet test -l "console;verbosity=minimal" --filter FullyQualifiedName~AuthenticationTests diff --git a/ci/test_authentication.sh b/ci/test_authentication.sh new file mode 100755 index 000000000..3043746fd --- /dev/null +++ b/ci/test_authentication.sh @@ -0,0 +1,31 @@ +#!/bin/bash -e + +set -o pipefail +export THIS_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )" +export WORKSPACE=${WORKSPACE:-/tmp} +export INTERNAL_REPO=nexus.int.snowflakecomputing.com:8086 + + +CI_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )" +if [[ -n "$JENKINS_HOME" ]]; then + ROOT_DIR="$(cd "${CI_DIR}/.." && pwd)" + export WORKSPACE=${WORKSPACE:-/tmp} + + source $CI_DIR/_init.sh + source $CI_DIR/scripts/login_internal_docker.sh + + echo "Use /sbin/ip" + IP_ADDR=$(/sbin/ip -4 addr show scope global dev eth0 | grep inet | awk '{print $2}' | cut -d / -f 1) + +fi + +gpg --quiet --batch --yes --decrypt --passphrase="$PARAMETERS_SECRET" --output $THIS_DIR/../.github/workflows/parameters/parameters_aws_auth_tests.json "$THIS_DIR/../.github/workflows/parameters/parameters_aws_auth_tests.json.gpg" +gpg --quiet --batch --yes --decrypt --passphrase="$PARAMETERS_SECRET" --output $THIS_DIR/../.github/workflows/parameters/rsa_keys/rsa_key.p8 "$THIS_DIR/../.github/workflows/parameters/rsa_keys/rsa_key.p8.gpg" +gpg --quiet --batch --yes --decrypt --passphrase="$PARAMETERS_SECRET" --output $THIS_DIR/../.github/workflows/parameters/rsa_keys/rsa_key_invalid.p8 "$THIS_DIR/../.github/workflows/parameters/rsa_keys/rsa_key_invalid.p8.gpg" + +docker run \ + -v $(cd $THIS_DIR/.. && pwd):/mnt/host \ + -v $WORKSPACE:/mnt/workspace \ + --rm \ + nexus.int.snowflakecomputing.com:8086/docker/snowdrivers-test-external-browser-dotnet:1 \ + "/mnt/host/ci/container/test_authentication.sh" From 63c289f6083708fb9956fc5374705ec5c3a3c67e Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Mon, 27 Jan 2025 13:49:18 +0100 Subject: [PATCH 03/41] jenkinsfile edit --- Jenkinsfile | 41 ++++++++++++++++++++++------------------- 1 file changed, 22 insertions(+), 19 deletions(-) diff --git a/Jenkinsfile b/Jenkinsfile index 13ec9265f..4ad09dc60 100644 --- a/Jenkinsfile +++ b/Jenkinsfile @@ -32,29 +32,32 @@ timestamps { string(name: 'parent_job', value: env.JOB_NAME), string(name: 'parent_build_number', value: env.BUILD_NUMBER) ] - parallel( - 'Test': { - stage('Test') { - build job: 'RT-LanguageGo-PC', parameters: params - } - }, - 'Test Authentication': { - stage('Test Authentication') { - withCredentials([ - string(credentialsId: 'a791118f-a1ea-46cd-b876-56da1b9bc71c', variable: 'NEXUS_PASSWORD'), - string(credentialsId: 'sfctest0-parameters-secret', variable: 'PARAMETERS_SECRET') - ]) { - sh '''\ - |#!/bin/bash -e - |$WORKSPACE/ci/test_authentication.sh - '''.stripMargin() + stage('Test') { + parallel( + 'Test': { + stage('Test') { + build job: 'RT-LanguageGo-PC', parameters: params + } + }, + 'Test Authentication': { + stage('Test Authentication') { + withCredentials([ + string(credentialsId: 'a791118f-a1ea-46cd-b876-56da1b9bc71c', variable: 'NEXUS_PASSWORD'), + string(credentialsId: 'sfctest0-parameters-secret', variable: 'PARAMETERS_SECRET') + ]) { + sh '''\ + |#!/bin/bash -e + |$WORKSPACE/ci/test_authentication.sh + '''.stripMargin() + } } } - } - ) + ) + } } } + pipeline { agent { label 'regular-memory-node' } options { timestamps() } @@ -80,4 +83,4 @@ def wgetUpdateGithub(String state, String folder, String targetUrl, String secon def ghURL = "https://api.github.com/repos/snowflakedb/snowflake-connector-net/statuses/$COMMIT_SHA_LONG" def data = JsonOutput.toJson([state: "${state}", context: "jenkins/${folder}",target_url: "${targetUrl}"]) sh "wget ${ghURL} --spider -q --header='Authorization: token $GIT_PASSWORD' --post-data='${data}'" -} +} \ No newline at end of file From 98f12380798585073116ee2673d749dd77707572 Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Mon, 27 Jan 2025 13:53:38 +0100 Subject: [PATCH 04/41] move params into jenkins --- Jenkinsfile | 27 +++++++++++++++------------ 1 file changed, 15 insertions(+), 12 deletions(-) diff --git a/Jenkinsfile b/Jenkinsfile index 4ad09dc60..04c7744cd 100644 --- a/Jenkinsfile +++ b/Jenkinsfile @@ -23,21 +23,24 @@ timestamps { '''.stripMargin() } } - params = [ - string(name: 'svn_revision', value: 'bptp-built'), - string(name: 'branch', value: 'main'), - string(name: 'client_git_commit', value: scmInfo.GIT_COMMIT), - string(name: 'client_git_branch', value: scmInfo.GIT_BRANCH), - string(name: 'TARGET_DOCKER_TEST_IMAGE', value: 'dotnet-ubuntu204-net9'), - string(name: 'parent_job', value: env.JOB_NAME), - string(name: 'parent_build_number', value: env.BUILD_NUMBER) - ] stage('Test') { parallel( 'Test': { - stage('Test') { - build job: 'RT-LanguageGo-PC', parameters: params - } + stage('Test') { + steps { + script { + build job: 'RT-LanguageGo-PC', parameters: [ + string(name: 'svn_revision', value: 'bptp-built'), + string(name: 'branch', value: 'main'), + string(name: 'client_git_commit', value: scmInfo.GIT_COMMIT), + string(name: 'client_git_branch', value: scmInfo.GIT_BRANCH), + string(name: 'TARGET_DOCKER_TEST_IMAGE', value: 'dotnet-ubuntu204-net9'), + string(name: 'parent_job', value: env.JOB_NAME), + string(name: 'parent_build_number', value: env.BUILD_NUMBER) + ] + } + } + } }, 'Test Authentication': { stage('Test Authentication') { From 7c3a967f65d93f508a50b211f9ff4a59a4b05b26 Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Mon, 27 Jan 2025 13:58:37 +0100 Subject: [PATCH 05/41] changes in jenkinsfile --- Jenkinsfile | 48 ++++++++++++++++++++---------------------------- 1 file changed, 20 insertions(+), 28 deletions(-) diff --git a/Jenkinsfile b/Jenkinsfile index 04c7744cd..7498a2ade 100644 --- a/Jenkinsfile +++ b/Jenkinsfile @@ -1,6 +1,5 @@ import groovy.json.JsonOutput - timestamps { node('regular-memory-node') { stage('checkout') { @@ -13,8 +12,8 @@ timestamps { stage('Build') { withCredentials([ usernamePassword(credentialsId: '063fc85b-62a6-4181-9d72-873b43488411', usernameVariable: 'AWS_ACCESS_KEY_ID', passwordVariable: 'AWS_SECRET_ACCESS_KEY'), - string(credentialsId: 'a791118f-a1ea-46cd-b876-56da1b9bc71c',variable: 'NEXUS_PASSWORD') - ]) { + string(credentialsId: 'a791118f-a1ea-46cd-b876-56da1b9bc71c', variable: 'NEXUS_PASSWORD') + ]) { sh '''\ |#!/bin/bash -e |export GIT_BRANCH=${GIT_BRANCH} @@ -23,24 +22,23 @@ timestamps { '''.stripMargin() } } + + def params = [ + string(name: 'svn_revision', value: 'bptp-built'), + string(name: 'branch', value: 'main'), + string(name: 'client_git_commit', value: scmInfo.GIT_COMMIT), + string(name: 'client_git_branch', value: scmInfo.GIT_BRANCH), + string(name: 'TARGET_DOCKER_TEST_IMAGE', value: 'dotnet-ubuntu204-net9'), + string(name: 'parent_job', value: env.JOB_NAME), + string(name: 'parent_build_number', value: env.BUILD_NUMBER) + ] + stage('Test') { parallel( 'Test': { - stage('Test') { - steps { - script { - build job: 'RT-LanguageGo-PC', parameters: [ - string(name: 'svn_revision', value: 'bptp-built'), - string(name: 'branch', value: 'main'), - string(name: 'client_git_commit', value: scmInfo.GIT_COMMIT), - string(name: 'client_git_branch', value: scmInfo.GIT_BRANCH), - string(name: 'TARGET_DOCKER_TEST_IMAGE', value: 'dotnet-ubuntu204-net9'), - string(name: 'parent_job', value: env.JOB_NAME), - string(name: 'parent_build_number', value: env.BUILD_NUMBER) - ] - } - } - } + stage('Test') { + build job: 'RT-LanguageGo-PC', parameters: params + } }, 'Test Authentication': { stage('Test Authentication') { @@ -60,17 +58,11 @@ timestamps { } } - pipeline { agent { label 'regular-memory-node' } options { timestamps() } environment { - COMMIT_SHA_LONG = sh(returnStdout: true, script: "echo \$(git rev-parse " + "HEAD)").trim() - - // environment variables for semgrep_agent (for findings / analytics page) - // remove .git at the end - // remove SCM URL + .git at the end - + COMMIT_SHA_LONG = sh(returnStdout: true, script: "echo \$(git rev-parse HEAD)").trim() BASELINE_BRANCH = "${env.CHANGE_TARGET}" } stages { @@ -83,7 +75,7 @@ pipeline { } def wgetUpdateGithub(String state, String folder, String targetUrl, String seconds) { - def ghURL = "https://api.github.com/repos/snowflakedb/snowflake-connector-net/statuses/$COMMIT_SHA_LONG" - def data = JsonOutput.toJson([state: "${state}", context: "jenkins/${folder}",target_url: "${targetUrl}"]) - sh "wget ${ghURL} --spider -q --header='Authorization: token $GIT_PASSWORD' --post-data='${data}'" + def ghURL = "https://api.github.com/repos/snowflakedb/snowflake-connector-net/statuses/$COMMIT_SHA_LONG" + def data = JsonOutput.toJson([state: "${state}", context: "jenkins/${folder}", target_url: "${targetUrl}"]) + sh "wget ${ghURL} --spider -q --header='Authorization: token $GIT_PASSWORD' --post-data='${data}'" } \ No newline at end of file From 2886a8b0c14ecd26fbd7f03747386c9e2081bf81 Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Mon, 27 Jan 2025 14:06:06 +0100 Subject: [PATCH 06/41] jenkinsfile with waiting --- Jenkinsfile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Jenkinsfile b/Jenkinsfile index 7498a2ade..3565dd8f2 100644 --- a/Jenkinsfile +++ b/Jenkinsfile @@ -37,7 +37,7 @@ timestamps { parallel( 'Test': { stage('Test') { - build job: 'RT-LanguageGo-PC', parameters: params + build job: 'RT-LanguageGo-PC', parameters: params, wait: true } }, 'Test Authentication': { From fb750154176859bfa07ab59604642ab74749aee4 Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Mon, 27 Jan 2025 14:10:59 +0100 Subject: [PATCH 07/41] image name change jenkins --- Jenkinsfile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Jenkinsfile b/Jenkinsfile index 3565dd8f2..4d474b555 100644 --- a/Jenkinsfile +++ b/Jenkinsfile @@ -37,7 +37,7 @@ timestamps { parallel( 'Test': { stage('Test') { - build job: 'RT-LanguageGo-PC', parameters: params, wait: true + build job: 'RT-LanguageDotnet-PC', parameters: params } }, 'Test Authentication': { From d1a1cdf544a10b3d981aaaa98df9273dfa4dc226 Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Mon, 27 Jan 2025 15:03:39 +0100 Subject: [PATCH 08/41] diagnostic jenkins --- ci/container/test_authentication.sh | 2 +- ci/test_authentication.sh | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/ci/container/test_authentication.sh b/ci/container/test_authentication.sh index 26d0b586b..9cdc966d4 100755 --- a/ci/container/test_authentication.sh +++ b/ci/container/test_authentication.sh @@ -12,4 +12,4 @@ eval $(jq -r '.authtestparams | to_entries | map("export \(.key)=\(.value|tostri export SNOWFLAKE_AUTH_TEST_PRIVATE_KEY_PATH=./.github/workflows/parameters/rsa_keys/rsa_key.p8 export SNOWFLAKE_AUTH_TEST_INVALID_PRIVATE_KEY_PATH=./.github/workflows/parameters/rsa_keys/rsa_key_invalid.p8 -dotnet test -l "console;verbosity=minimal" --filter FullyQualifiedName~AuthenticationTests +dotnet test -l "console;verbosity=diagnostic" --filter FullyQualifiedName~AuthenticationTests diff --git a/ci/test_authentication.sh b/ci/test_authentication.sh index 3043746fd..0b3ac4495 100755 --- a/ci/test_authentication.sh +++ b/ci/test_authentication.sh @@ -27,5 +27,6 @@ docker run \ -v $(cd $THIS_DIR/.. && pwd):/mnt/host \ -v $WORKSPACE:/mnt/workspace \ --rm \ + --platform=linux/amd64 \ nexus.int.snowflakecomputing.com:8086/docker/snowdrivers-test-external-browser-dotnet:1 \ "/mnt/host/ci/container/test_authentication.sh" From 0e403f6caf90d8e26f9e3a00923667f35ef486ba Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Mon, 27 Jan 2025 16:09:24 +0100 Subject: [PATCH 09/41] with agent --- Jenkinsfile | 6 ++++++ Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs | 2 +- 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/Jenkinsfile b/Jenkinsfile index 4d474b555..d4fd81e66 100644 --- a/Jenkinsfile +++ b/Jenkinsfile @@ -42,6 +42,12 @@ timestamps { }, 'Test Authentication': { stage('Test Authentication') { + agent { + docker { + image 'dotnet-centos7-net6' + args '-u root:root' + } + } withCredentials([ string(credentialsId: 'a791118f-a1ea-46cd-b876-56da1b9bc71c', variable: 'NEXUS_PASSWORD'), string(credentialsId: 'sfctest0-parameters-secret', variable: 'PARAMETERS_SECRET') diff --git a/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs index e3094fd61..9a306457a 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs @@ -44,7 +44,7 @@ public void TestAuthenticateUsingOauthInvalidToken() authTestHelper.VerifyExceptionIsThrown("Invalid OAuth access token"); } - [Test, Ignore("Skipped, waits for SNOW-1893041"), IgnoreOnCI] + [Test, IgnoreOnCI] public void TestAuthenticateUsingOauthMismatchedUser() { AuthTestHelper authTestHelper = new AuthTestHelper(); From d3b9dabfbcad5fa7a356eef1634f5f66a0629221 Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Mon, 27 Jan 2025 16:40:26 +0100 Subject: [PATCH 10/41] without browser --- .../ExternalBrowserConnection.cs | 198 +++++++++--------- .../AuthenticationTests/OktaConnection.cs | 188 ++++++++--------- 2 files changed, 193 insertions(+), 193 deletions(-) diff --git a/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs index c050f5f5f..e050e6091 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs @@ -1,99 +1,99 @@ -/* - * Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved. - */ - -using System.Threading; -using NUnit.Framework; -using Snowflake.Data.Core; - -namespace Snowflake.Data.Tests.AuthenticationTests -{ - - [NonParallelizable] - public class ExternalBrowserConnectionTest : SFBaseTest - { - private string _connectionString = ""; - private string _login = AuthConnectionString.SsoUser; - private string _password = AuthConnectionString.SsoPassword; - - [SetUp] - public void SetUp() - { - AuthTestHelper authTestHelper = new AuthTestHelper(); - _login = AuthConnectionString.SsoUser; - _password = AuthConnectionString.SsoPassword; - authTestHelper.CleanBrowserProcess(); - var parameters = AuthConnectionString.GetExternalBrowserConnectionString(); - _connectionString = AuthConnectionString.SetExternalBrowserConnectionString(parameters); - } - - [Test, IgnoreOnCI] - public void TestAuthenticateUsingExternalBrowserSuccessful() - { - AuthTestHelper authTestHelper = new AuthTestHelper(); - - Thread connectThread = authTestHelper.GetConnectAndExecuteSimpleQueryThread(_connectionString); - Thread provideCredentialsThread = authTestHelper.GetProvideCredentialsThread("success", _login, _password); - - authTestHelper.ConnectAndProvideCredentials(provideCredentialsThread, connectThread); - authTestHelper.VerifyExceptionIsNotThrown(); - - } - - [Test, IgnoreOnCI] - public void TestAuthenticateUsingExternalBrowserMismatchedUser() - { - AuthTestHelper authTestHelper = new AuthTestHelper(); - - var parameters = AuthConnectionString.GetExternalBrowserConnectionString(); - parameters[SFSessionProperty.USER] = "differentUser"; - - _connectionString = AuthConnectionString.SetExternalBrowserConnectionString(parameters); - - Thread connectThread = authTestHelper.GetConnectAndExecuteSimpleQueryThread(_connectionString); - Thread provideCredentialsThread = authTestHelper.GetProvideCredentialsThread("success", _login, _password); - - authTestHelper.ConnectAndProvideCredentials(provideCredentialsThread, connectThread); - authTestHelper.VerifyExceptionIsThrown("The user you were trying to authenticate as differs from the user currently logged in at the IDP"); - - } - - [Test, IgnoreOnCI] - public void TestAuthenticateUsingExternalBrowserWrongCredentials() - { - AuthTestHelper authTestHelper = new AuthTestHelper(); - - var parameters = AuthConnectionString.GetExternalBrowserConnectionString(); - - _connectionString = AuthConnectionString.SetExternalBrowserConnectionString(parameters); - _connectionString += "BROWSER_RESPONSE_TIMEOUT=15;"; - - _login = "itsnotanaccount.com"; - _password = "fakepassword"; - - Thread connectThread = authTestHelper.GetConnectAndExecuteSimpleQueryThread(_connectionString); - Thread provideCredentialsThread = authTestHelper.GetProvideCredentialsThread("fail", _login, _password); - - authTestHelper.ConnectAndProvideCredentials(provideCredentialsThread, connectThread); - authTestHelper.VerifyExceptionIsThrown("Browser response timed out after 15 seconds"); - - } - - [Test, IgnoreOnCI] - public void TestAuthenticateUsingExternalBrowserTimeout() - { - AuthTestHelper authTestHelper = new AuthTestHelper(); - - var parameters = AuthConnectionString.GetExternalBrowserConnectionString(); - - _connectionString = AuthConnectionString.SetExternalBrowserConnectionString(parameters); - _connectionString += "BROWSER_RESPONSE_TIMEOUT=1;"; - - Thread connectThread = authTestHelper.GetConnectAndExecuteSimpleQueryThread(_connectionString); - Thread provideCredentialsThread = authTestHelper.GetProvideCredentialsThread("timeout", _login, _password); - - authTestHelper.ConnectAndProvideCredentials(provideCredentialsThread, connectThread); - authTestHelper.VerifyExceptionIsThrown("Browser response timed out after 1 seconds"); - } - } -} +// /* +// * Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved. +// */ +// +// using System.Threading; +// using NUnit.Framework; +// using Snowflake.Data.Core; +// +// namespace Snowflake.Data.Tests.AuthenticationTests +// { +// +// [NonParallelizable] +// public class ExternalBrowserConnectionTest : SFBaseTest +// { +// private string _connectionString = ""; +// private string _login = AuthConnectionString.SsoUser; +// private string _password = AuthConnectionString.SsoPassword; +// +// [SetUp] +// public void SetUp() +// { +// AuthTestHelper authTestHelper = new AuthTestHelper(); +// _login = AuthConnectionString.SsoUser; +// _password = AuthConnectionString.SsoPassword; +// authTestHelper.CleanBrowserProcess(); +// var parameters = AuthConnectionString.GetExternalBrowserConnectionString(); +// _connectionString = AuthConnectionString.SetExternalBrowserConnectionString(parameters); +// } +// +// [Test, IgnoreOnCI] +// public void TestAuthenticateUsingExternalBrowserSuccessful() +// { +// AuthTestHelper authTestHelper = new AuthTestHelper(); +// +// Thread connectThread = authTestHelper.GetConnectAndExecuteSimpleQueryThread(_connectionString); +// Thread provideCredentialsThread = authTestHelper.GetProvideCredentialsThread("success", _login, _password); +// +// authTestHelper.ConnectAndProvideCredentials(provideCredentialsThread, connectThread); +// authTestHelper.VerifyExceptionIsNotThrown(); +// +// } +// +// [Test, IgnoreOnCI] +// public void TestAuthenticateUsingExternalBrowserMismatchedUser() +// { +// AuthTestHelper authTestHelper = new AuthTestHelper(); +// +// var parameters = AuthConnectionString.GetExternalBrowserConnectionString(); +// parameters[SFSessionProperty.USER] = "differentUser"; +// +// _connectionString = AuthConnectionString.SetExternalBrowserConnectionString(parameters); +// +// Thread connectThread = authTestHelper.GetConnectAndExecuteSimpleQueryThread(_connectionString); +// Thread provideCredentialsThread = authTestHelper.GetProvideCredentialsThread("success", _login, _password); +// +// authTestHelper.ConnectAndProvideCredentials(provideCredentialsThread, connectThread); +// authTestHelper.VerifyExceptionIsThrown("The user you were trying to authenticate as differs from the user currently logged in at the IDP"); +// +// } +// +// [Test, IgnoreOnCI] +// public void TestAuthenticateUsingExternalBrowserWrongCredentials() +// { +// AuthTestHelper authTestHelper = new AuthTestHelper(); +// +// var parameters = AuthConnectionString.GetExternalBrowserConnectionString(); +// +// _connectionString = AuthConnectionString.SetExternalBrowserConnectionString(parameters); +// _connectionString += "BROWSER_RESPONSE_TIMEOUT=15;"; +// +// _login = "itsnotanaccount.com"; +// _password = "fakepassword"; +// +// Thread connectThread = authTestHelper.GetConnectAndExecuteSimpleQueryThread(_connectionString); +// Thread provideCredentialsThread = authTestHelper.GetProvideCredentialsThread("fail", _login, _password); +// +// authTestHelper.ConnectAndProvideCredentials(provideCredentialsThread, connectThread); +// authTestHelper.VerifyExceptionIsThrown("Browser response timed out after 15 seconds"); +// +// } +// +// [Test, IgnoreOnCI] +// public void TestAuthenticateUsingExternalBrowserTimeout() +// { +// AuthTestHelper authTestHelper = new AuthTestHelper(); +// +// var parameters = AuthConnectionString.GetExternalBrowserConnectionString(); +// +// _connectionString = AuthConnectionString.SetExternalBrowserConnectionString(parameters); +// _connectionString += "BROWSER_RESPONSE_TIMEOUT=1;"; +// +// Thread connectThread = authTestHelper.GetConnectAndExecuteSimpleQueryThread(_connectionString); +// Thread provideCredentialsThread = authTestHelper.GetProvideCredentialsThread("timeout", _login, _password); +// +// authTestHelper.ConnectAndProvideCredentials(provideCredentialsThread, connectThread); +// authTestHelper.VerifyExceptionIsThrown("Browser response timed out after 1 seconds"); +// } +// } +// } diff --git a/Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs index 68718061c..e7f1ebc1d 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs @@ -1,94 +1,94 @@ -/* - * Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved. - */ - -using NUnit.Framework; -using Snowflake.Data.Core; - -namespace Snowflake.Data.Tests.AuthenticationTests -{ - - [NonParallelizable] - public class OktaConnectionTest : SFBaseTest - { - private string _connectionString = ""; - - [SetUp] - public void SetUp() - { - AuthTestHelper authTestHelper = new AuthTestHelper(); - - var parameters = AuthConnectionString.GetOktaConnectionString(); - _connectionString = AuthConnectionString.SetOktaConnectionString(parameters); - authTestHelper.CleanBrowserProcess(); - - } - - [Test, IgnoreOnCI] - public void TestAuthenticateUsingOktaSuccessful() - { - AuthTestHelper authTestHelper = new AuthTestHelper(); - - authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); - authTestHelper.VerifyExceptionIsNotThrown(); - - } - - [Test, IgnoreOnCI] - public void TestAuthenticateUsingOktaWrongUsernameParam() - { - AuthTestHelper authTestHelper = new AuthTestHelper(); - - var parameters = AuthConnectionString.GetOktaConnectionString(); - parameters[SFSessionProperty.USER] = "differentUser"; - _connectionString = AuthConnectionString.SetOktaConnectionString(parameters); - - authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); - authTestHelper.VerifyExceptionIsThrown("401 (Unauthorized)"); - } - - [Test, IgnoreOnCI] - public void TestAuthenticateUsingOktaWrongCredentials() - { - AuthTestHelper authTestHelper = new AuthTestHelper(); - - var parameters = AuthConnectionString.GetOktaConnectionString(); - parameters[SFSessionProperty.USER] = "differentUser"; - parameters[SFSessionProperty.PASSWORD] = "fakepassword"; - - _connectionString = AuthConnectionString.SetOktaConnectionString(parameters); - - authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); - authTestHelper.VerifyExceptionIsThrown("401 (Unauthorized)"); - } - - [Test, IgnoreOnCI] - public void TestAuthenticateUsingOktaWrongUrl() - { - AuthTestHelper authTestHelper = new AuthTestHelper(); - - var parameters = AuthConnectionString.GetOktaConnectionString(); - parameters[SFSessionProperty.AUTHENTICATOR] = "https://invalid.okta.com/"; - - _connectionString = AuthConnectionString.SetOktaConnectionString(parameters); - - authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); - authTestHelper.VerifyExceptionIsThrown("The specified authenticator is not accepted by your Snowflake account configuration"); - } - - - [Test, IgnoreOnCI] - public void TestAuthenticateUsingUrlWithoutOkta() - { - AuthTestHelper authTestHelper = new AuthTestHelper(); - - var parameters = AuthConnectionString.GetOktaConnectionString(); - parameters[SFSessionProperty.AUTHENTICATOR] = "https://invalid.abc.com/"; - - _connectionString = AuthConnectionString.SetOktaConnectionString(parameters); - - authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); - authTestHelper.VerifyExceptionIsThrown("Unknown authenticator"); - } - } -} +// /* +// * Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved. +// */ +// +// using NUnit.Framework; +// using Snowflake.Data.Core; +// +// namespace Snowflake.Data.Tests.AuthenticationTests +// { +// +// [NonParallelizable] +// public class OktaConnectionTest : SFBaseTest +// { +// private string _connectionString = ""; +// +// [SetUp] +// public void SetUp() +// { +// AuthTestHelper authTestHelper = new AuthTestHelper(); +// +// var parameters = AuthConnectionString.GetOktaConnectionString(); +// _connectionString = AuthConnectionString.SetOktaConnectionString(parameters); +// authTestHelper.CleanBrowserProcess(); +// +// } +// +// [Test, IgnoreOnCI] +// public void TestAuthenticateUsingOktaSuccessful() +// { +// AuthTestHelper authTestHelper = new AuthTestHelper(); +// +// authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); +// authTestHelper.VerifyExceptionIsNotThrown(); +// +// } +// +// [Test, IgnoreOnCI] +// public void TestAuthenticateUsingOktaWrongUsernameParam() +// { +// AuthTestHelper authTestHelper = new AuthTestHelper(); +// +// var parameters = AuthConnectionString.GetOktaConnectionString(); +// parameters[SFSessionProperty.USER] = "differentUser"; +// _connectionString = AuthConnectionString.SetOktaConnectionString(parameters); +// +// authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); +// authTestHelper.VerifyExceptionIsThrown("401 (Unauthorized)"); +// } +// +// [Test, IgnoreOnCI] +// public void TestAuthenticateUsingOktaWrongCredentials() +// { +// AuthTestHelper authTestHelper = new AuthTestHelper(); +// +// var parameters = AuthConnectionString.GetOktaConnectionString(); +// parameters[SFSessionProperty.USER] = "differentUser"; +// parameters[SFSessionProperty.PASSWORD] = "fakepassword"; +// +// _connectionString = AuthConnectionString.SetOktaConnectionString(parameters); +// +// authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); +// authTestHelper.VerifyExceptionIsThrown("401 (Unauthorized)"); +// } +// +// [Test, IgnoreOnCI] +// public void TestAuthenticateUsingOktaWrongUrl() +// { +// AuthTestHelper authTestHelper = new AuthTestHelper(); +// +// var parameters = AuthConnectionString.GetOktaConnectionString(); +// parameters[SFSessionProperty.AUTHENTICATOR] = "https://invalid.okta.com/"; +// +// _connectionString = AuthConnectionString.SetOktaConnectionString(parameters); +// +// authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); +// authTestHelper.VerifyExceptionIsThrown("The specified authenticator is not accepted by your Snowflake account configuration"); +// } +// +// +// [Test, IgnoreOnCI] +// public void TestAuthenticateUsingUrlWithoutOkta() +// { +// AuthTestHelper authTestHelper = new AuthTestHelper(); +// +// var parameters = AuthConnectionString.GetOktaConnectionString(); +// parameters[SFSessionProperty.AUTHENTICATOR] = "https://invalid.abc.com/"; +// +// _connectionString = AuthConnectionString.SetOktaConnectionString(parameters); +// +// authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); +// authTestHelper.VerifyExceptionIsThrown("Unknown authenticator"); +// } +// } +// } From d5129867dc19334713b46fb2f6a0d0d3ccacb154 Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Mon, 27 Jan 2025 16:58:49 +0100 Subject: [PATCH 11/41] no mismatched user --- .../AuthenticationTests/OauthConnection.cs | 28 +++++++++---------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs index 9a306457a..54417b2ec 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs @@ -44,19 +44,19 @@ public void TestAuthenticateUsingOauthInvalidToken() authTestHelper.VerifyExceptionIsThrown("Invalid OAuth access token"); } - [Test, IgnoreOnCI] - public void TestAuthenticateUsingOauthMismatchedUser() - { - AuthTestHelper authTestHelper = new AuthTestHelper(); - - string token = AuthConnectionString.GetOauthToken(); - var parameters = AuthConnectionString.GetOauthConnectionString(token); - parameters[SFSessionProperty.USER] = "fakeAccount"; - _connectionString = AuthConnectionString.SetOauthConnectionString(parameters) + ";poolingEnabled=false;minPoolSize=0;"; - - authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); - authTestHelper.VerifyExceptionIsThrown("The user you were trying to authenticate as differs from the user tied to the access token"); - - } + // [Test, Ignore("Skipped, waits for SNOW-1893041")] + // public void TestAuthenticateUsingOauthMismatchedUser() + // { + // AuthTestHelper authTestHelper = new AuthTestHelper(); + // + // string token = AuthConnectionString.GetOauthToken(); + // var parameters = AuthConnectionString.GetOauthConnectionString(token); + // parameters[SFSessionProperty.USER] = "fakeAccount"; + // _connectionString = AuthConnectionString.SetOauthConnectionString(parameters) + ";poolingEnabled=false;minPoolSize=0;"; + // + // authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); + // authTestHelper.VerifyExceptionIsThrown("The user you were trying to authenticate as differs from the user tied to the access token"); + // + // } } } From a90deca0138a839dc955cceb4b3f944fda9679d9 Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Tue, 28 Jan 2025 10:48:25 +0100 Subject: [PATCH 12/41] only one test --- .../AuthenticationTests/KeyPairConnection.cs | 85 ++++++------ .../AuthenticationTests/OauthConnection.cs | 124 +++++++++--------- 2 files changed, 105 insertions(+), 104 deletions(-) diff --git a/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs index f71c455dc..fb4d513f0 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs @@ -2,6 +2,7 @@ * Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved. */ +using System; using NUnit.Framework; @@ -16,55 +17,55 @@ public class KeyPairConnectionTest : SFBaseTest [Test, IgnoreOnCI] - public void TestAuthenticateUsingKeyPairFilcContentSuccessful() + public void TestAuthenticateUsingKeyPairFileContentSuccessful() { AuthTestHelper authTestHelper = new AuthTestHelper(); var privateKey = AuthConnectionString.GetPrivateKeyContentForKeypairAuth("SNOWFLAKE_AUTH_TEST_PRIVATE_KEY_PATH"); var parameters = AuthConnectionString.GetKeyPairFromFileContentParameters(privateKey); _connectionString = AuthConnectionString.SetPrivateKeyFromFileContentConnectionString(parameters); - + Console.WriteLine(_connectionString); authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); authTestHelper.VerifyExceptionIsNotThrown(); } - - [Test, IgnoreOnCI] - public void TestAuthenticateUsingKeyPairFileContentInvalidKey() - { - AuthTestHelper authTestHelper = new AuthTestHelper(); - - var privateKey = AuthConnectionString.GetPrivateKeyContentForKeypairAuth("SNOWFLAKE_AUTH_TEST_INVALID_PRIVATE_KEY_PATH"); - var parameters = AuthConnectionString.GetKeyPairFromFileContentParameters(privateKey); - _connectionString = AuthConnectionString.SetPrivateKeyFromFileContentConnectionString(parameters); - - authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); - authTestHelper.VerifyExceptionIsThrown("Error: JWT token is invalid"); - } - - [Test, IgnoreOnCI] - public void TestAuthenticateUsingKeyPairFilePathSuccessful() - { - AuthTestHelper authTestHelper = new AuthTestHelper(); - - var privateKeyPath = AuthConnectionString.GetPrivateKeyPathForKeypairAuth("SNOWFLAKE_AUTH_TEST_PRIVATE_KEY_PATH"); - var parameters = AuthConnectionString.GetKeyPairFromFilePathConnectionString(privateKeyPath); - _connectionString = AuthConnectionString.SetPrivateKeyFromFilePathConnectionString(parameters); - - authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); - authTestHelper.VerifyExceptionIsNotThrown(); - } - - [Test, IgnoreOnCI] - public void TestAuthenticateUsingKeyPairFilePathInvalidKey() - { - AuthTestHelper authTestHelper = new AuthTestHelper(); - - var privateKeyPath = AuthConnectionString.GetPrivateKeyPathForKeypairAuth("SNOWFLAKE_AUTH_TEST_INVALID_PRIVATE_KEY_PATH"); - var parameters = AuthConnectionString.GetKeyPairFromFilePathConnectionString(privateKeyPath); - _connectionString = AuthConnectionString.SetPrivateKeyFromFilePathConnectionString(parameters); - - authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); - authTestHelper.VerifyExceptionIsThrown("Error: JWT token is invalid"); - } - } +// // +// // [Test, IgnoreOnCI] +// // public void TestAuthenticateUsingKeyPairFileContentInvalidKey() +// // { +// // AuthTestHelper authTestHelper = new AuthTestHelper(); +// // +// // var privateKey = AuthConnectionString.GetPrivateKeyContentForKeypairAuth("SNOWFLAKE_AUTH_TEST_INVALID_PRIVATE_KEY_PATH"); +// // var parameters = AuthConnectionString.GetKeyPairFromFileContentParameters(privateKey); +// // _connectionString = AuthConnectionString.SetPrivateKeyFromFileContentConnectionString(parameters); +// // +// // authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); +// // authTestHelper.VerifyExceptionIsThrown("Error: JWT token is invalid"); +// // } +// // +// // [Test, IgnoreOnCI] +// // public void TestAuthenticateUsingKeyPairFilePathSuccessful() +// // { +// // AuthTestHelper authTestHelper = new AuthTestHelper(); +// // +// // var privateKeyPath = AuthConnectionString.GetPrivateKeyPathForKeypairAuth("SNOWFLAKE_AUTH_TEST_PRIVATE_KEY_PATH"); +// // var parameters = AuthConnectionString.GetKeyPairFromFilePathConnectionString(privateKeyPath); +// // _connectionString = AuthConnectionString.SetPrivateKeyFromFilePathConnectionString(parameters); +// // +// // authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); +// // authTestHelper.VerifyExceptionIsNotThrown(); +// // } +// // +// // [Test, IgnoreOnCI] +// // public void TestAuthenticateUsingKeyPairFilePathInvalidKey() +// // { +// // AuthTestHelper authTestHelper = new AuthTestHelper(); +// // +// // var privateKeyPath = AuthConnectionString.GetPrivateKeyPathForKeypairAuth("SNOWFLAKE_AUTH_TEST_INVALID_PRIVATE_KEY_PATH"); +// // var parameters = AuthConnectionString.GetKeyPairFromFilePathConnectionString(privateKeyPath); +// // _connectionString = AuthConnectionString.SetPrivateKeyFromFilePathConnectionString(parameters); +// // +// // authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); +// // authTestHelper.VerifyExceptionIsThrown("Error: JWT token is invalid"); +// // } + } } diff --git a/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs index 54417b2ec..c40a6c593 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs @@ -1,62 +1,62 @@ -/* - * Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved. - */ - -using NUnit.Framework; -using Snowflake.Data.Core; - -namespace Snowflake.Data.Tests.AuthenticationTests -{ - - [NonParallelizable] - public class OauthConnectionTest : SFBaseTest - { - private string _connectionString = ""; - - [SetUp] - public void SetUp() - { - string token = AuthConnectionString.GetOauthToken(); - var parameters = AuthConnectionString.GetOauthConnectionString(token); - _connectionString = AuthConnectionString.SetOauthConnectionString(parameters); - - } - - [Test, IgnoreOnCI] - public void TestAuthenticateUsingOauthSuccessful() - { - AuthTestHelper authTestHelper = new AuthTestHelper(); - - authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); - authTestHelper.VerifyExceptionIsNotThrown(); - } - - [Test, IgnoreOnCI] - public void TestAuthenticateUsingOauthInvalidToken() - { - AuthTestHelper authTestHelper = new AuthTestHelper(); - - string token = "invalidToken"; - var parameters = AuthConnectionString.GetOauthConnectionString(token); - _connectionString = AuthConnectionString.SetOauthConnectionString(parameters); - - authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); - authTestHelper.VerifyExceptionIsThrown("Invalid OAuth access token"); - } - - // [Test, Ignore("Skipped, waits for SNOW-1893041")] - // public void TestAuthenticateUsingOauthMismatchedUser() - // { - // AuthTestHelper authTestHelper = new AuthTestHelper(); - // - // string token = AuthConnectionString.GetOauthToken(); - // var parameters = AuthConnectionString.GetOauthConnectionString(token); - // parameters[SFSessionProperty.USER] = "fakeAccount"; - // _connectionString = AuthConnectionString.SetOauthConnectionString(parameters) + ";poolingEnabled=false;minPoolSize=0;"; - // - // authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); - // authTestHelper.VerifyExceptionIsThrown("The user you were trying to authenticate as differs from the user tied to the access token"); - // - // } - } -} +// /* +// * Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved. +// */ +// +// using NUnit.Framework; +// using Snowflake.Data.Core; +// +// namespace Snowflake.Data.Tests.AuthenticationTests +// { +// +// [NonParallelizable] +// public class OauthConnectionTest : SFBaseTest +// { +// private string _connectionString = ""; +// +// [SetUp] +// public void SetUp() +// { +// string token = AuthConnectionString.GetOauthToken(); +// var parameters = AuthConnectionString.GetOauthConnectionString(token); +// _connectionString = AuthConnectionString.SetOauthConnectionString(parameters); +// +// } +// +// // [Test, IgnoreOnCI] +// // public void TestAuthenticateUsingOauthSuccessful() +// // { +// // AuthTestHelper authTestHelper = new AuthTestHelper(); +// // +// // authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); +// // authTestHelper.VerifyExceptionIsNotThrown(); +// // } +// // +// // [Test, IgnoreOnCI] +// // public void TestAuthenticateUsingOauthInvalidToken() +// // { +// // AuthTestHelper authTestHelper = new AuthTestHelper(); +// // +// // string token = "invalidToken"; +// // var parameters = AuthConnectionString.GetOauthConnectionString(token); +// // _connectionString = AuthConnectionString.SetOauthConnectionString(parameters); +// // +// // authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); +// // authTestHelper.VerifyExceptionIsThrown("Invalid OAuth access token"); +// // } +// +// // [Test, Ignore("Skipped, waits for SNOW-1893041")] +// // public void TestAuthenticateUsingOauthMismatchedUser() +// // { +// // AuthTestHelper authTestHelper = new AuthTestHelper(); +// // +// // string token = AuthConnectionString.GetOauthToken(); +// // var parameters = AuthConnectionString.GetOauthConnectionString(token); +// // parameters[SFSessionProperty.USER] = "fakeAccount"; +// // _connectionString = AuthConnectionString.SetOauthConnectionString(parameters) + ";poolingEnabled=false;minPoolSize=0;"; +// // +// // authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); +// // authTestHelper.VerifyExceptionIsThrown("The user you were trying to authenticate as differs from the user tied to the access token"); +// // +// // } +// } +// } From 698a726c2c2d41d9295372f1176e1d44dc702ddd Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Tue, 28 Jan 2025 11:15:24 +0100 Subject: [PATCH 13/41] adding stamps --- .../AuthenticationTests/KeyPairConnection.cs | 5 ++-- Snowflake.Data.Tests/SFBaseTest.cs | 24 +++++++++++++++++++ 2 files changed, 27 insertions(+), 2 deletions(-) diff --git a/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs index fb4d513f0..ca982b893 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs @@ -4,6 +4,7 @@ using System; using NUnit.Framework; +using NUnit.Framework.Internal; @@ -16,15 +17,15 @@ public class KeyPairConnectionTest : SFBaseTest private string _connectionString = ""; - [Test, IgnoreOnCI] + [Test] public void TestAuthenticateUsingKeyPairFileContentSuccessful() { + Console.WriteLine("Before test, after setup"); AuthTestHelper authTestHelper = new AuthTestHelper(); var privateKey = AuthConnectionString.GetPrivateKeyContentForKeypairAuth("SNOWFLAKE_AUTH_TEST_PRIVATE_KEY_PATH"); var parameters = AuthConnectionString.GetKeyPairFromFileContentParameters(privateKey); _connectionString = AuthConnectionString.SetPrivateKeyFromFileContentConnectionString(parameters); - Console.WriteLine(_connectionString); authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); authTestHelper.VerifyExceptionIsNotThrown(); } diff --git a/Snowflake.Data.Tests/SFBaseTest.cs b/Snowflake.Data.Tests/SFBaseTest.cs index 2784f0e25..832c6c589 100755 --- a/Snowflake.Data.Tests/SFBaseTest.cs +++ b/Snowflake.Data.Tests/SFBaseTest.cs @@ -35,6 +35,8 @@ public class SFBaseTest : SFBaseTestAsync [SetUp] public static void SetUpContext() { + Console.WriteLine("Setup context"); + MockSynchronizationContext.SetupContext(); } @@ -74,6 +76,8 @@ public class SFBaseTestAsync [SetUp] public void BeforeTest() { + Console.WriteLine("BEFORE TEST METHOD"); + _stopwatch = new Stopwatch(); _stopwatch.Start(); _tablesToRemove = new List(); @@ -82,6 +86,8 @@ public void BeforeTest() [TearDown] public void AfterTest() { + Console.WriteLine("AFTER TEST METHOD"); + _stopwatch.Stop(); var testName = $"{TestContext.CurrentContext.Test.FullName}"; @@ -91,6 +97,8 @@ public void AfterTest() private void RemoveTables() { + Console.WriteLine("REMOVE TABLE TEST METHOD"); + if (_tablesToRemove.Count == 0) return; @@ -110,6 +118,8 @@ private void RemoveTables() protected void CreateOrReplaceTable(IDbConnection conn, string tableName, IEnumerable columns, string additionalQueryStr = null) { + Console.WriteLine("CREATE OR REPLACE"); + CreateOrReplaceTable(conn, tableName, "", columns, additionalQueryStr); } @@ -131,6 +141,8 @@ protected void AddTableToRemoveList(string tableName) public SFBaseTestAsync() { + Console.WriteLine("TEST CONFIG SETUP"); + testConfig = TestEnvironment.TestConfig; } @@ -185,6 +197,8 @@ public static void RecordTestPerformance(string name, TimeSpan time) [OneTimeSetUp] public void Setup() { + Console.WriteLine("one time setup"); + #if NETFRAMEWORK log4net.GlobalContext.Properties["framework"] = "net471"; log4net.Config.XmlConfigurator.Configure(); @@ -240,6 +254,8 @@ public void SetupTestPerformance() [OneTimeTearDown] public void CreateTestTimeArtifact() { + Console.WriteLine("CREATE TIME"); + var resultText = "test;time_in_ms\n"; resultText += string.Join("\n", s_testPerformance.Select(test => $"{test.Key};{Math.Round(test.Value.TotalMilliseconds,0)}")); @@ -275,6 +291,8 @@ private static void ModifySchema(string schemaName, SchemaAction schemaAction) { using (IDbConnection conn = new SnowflakeDbConnection()) { + Console.WriteLine("MODIFY SCHEMA"); + conn.ConnectionString = s_connectionString; conn.Open(); var dbCommand = conn.CreateCommand(); @@ -305,14 +323,20 @@ private static string GetOs() { if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { + Console.WriteLine("WIN"); + return "windows"; } if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) { + Console.WriteLine("LIN"); + return "linux"; } if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) { + Console.WriteLine("MACOS"); + return "macos"; } From 37dfd047cf844fc0a1570d337111a5d37512e8a0 Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Tue, 28 Jan 2025 11:25:09 +0100 Subject: [PATCH 14/41] s_logger --- .../AuthenticationTests/KeyPairConnection.cs | 8 +++-- Snowflake.Data.Tests/SFBaseTest.cs | 29 +++++++++++-------- 2 files changed, 23 insertions(+), 14 deletions(-) diff --git a/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs index ca982b893..18b4e6632 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs @@ -5,6 +5,7 @@ using System; using NUnit.Framework; using NUnit.Framework.Internal; +using Snowflake.Data.Log; @@ -16,16 +17,19 @@ public class KeyPairConnectionTest : SFBaseTest { private string _connectionString = ""; + private static readonly SFLogger s_logger = SFLoggerFactory.GetLogger(); - [Test] + [Test, IgnoreOnCI] public void TestAuthenticateUsingKeyPairFileContentSuccessful() + { + s_logger.Debug("Before test, after setup"); Console.WriteLine("Before test, after setup"); AuthTestHelper authTestHelper = new AuthTestHelper(); - var privateKey = AuthConnectionString.GetPrivateKeyContentForKeypairAuth("SNOWFLAKE_AUTH_TEST_PRIVATE_KEY_PATH"); var parameters = AuthConnectionString.GetKeyPairFromFileContentParameters(privateKey); _connectionString = AuthConnectionString.SetPrivateKeyFromFileContentConnectionString(parameters); + s_logger.Debug(_connectionString); authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); authTestHelper.VerifyExceptionIsNotThrown(); } diff --git a/Snowflake.Data.Tests/SFBaseTest.cs b/Snowflake.Data.Tests/SFBaseTest.cs index 832c6c589..20cc88bdd 100755 --- a/Snowflake.Data.Tests/SFBaseTest.cs +++ b/Snowflake.Data.Tests/SFBaseTest.cs @@ -32,10 +32,13 @@ namespace Snowflake.Data.Tests [TestFixture] public class SFBaseTest : SFBaseTestAsync { + private static readonly SFLogger s_logger = SFLoggerFactory.GetLogger(); + [SetUp] public static void SetUpContext() { - Console.WriteLine("Setup context"); + s_logger.Debug("Setup context"); + s_logger.Debug("Setup context"); MockSynchronizationContext.SetupContext(); } @@ -76,7 +79,7 @@ public class SFBaseTestAsync [SetUp] public void BeforeTest() { - Console.WriteLine("BEFORE TEST METHOD"); + s_logger.Debug("BEFORE TEST METHOD"); _stopwatch = new Stopwatch(); _stopwatch.Start(); @@ -86,7 +89,7 @@ public void BeforeTest() [TearDown] public void AfterTest() { - Console.WriteLine("AFTER TEST METHOD"); + s_logger.Debug("AFTER TEST METHOD"); _stopwatch.Stop(); var testName = $"{TestContext.CurrentContext.Test.FullName}"; @@ -97,7 +100,7 @@ public void AfterTest() private void RemoveTables() { - Console.WriteLine("REMOVE TABLE TEST METHOD"); + s_logger.Debug("REMOVE TABLE TEST METHOD"); if (_tablesToRemove.Count == 0) return; @@ -118,7 +121,7 @@ private void RemoveTables() protected void CreateOrReplaceTable(IDbConnection conn, string tableName, IEnumerable columns, string additionalQueryStr = null) { - Console.WriteLine("CREATE OR REPLACE"); + s_logger.Debug("CREATE OR REPLACE"); CreateOrReplaceTable(conn, tableName, "", columns, additionalQueryStr); } @@ -141,7 +144,7 @@ protected void AddTableToRemoveList(string tableName) public SFBaseTestAsync() { - Console.WriteLine("TEST CONFIG SETUP"); + s_logger.Debug("TEST CONFIG SETUP"); testConfig = TestEnvironment.TestConfig; } @@ -177,6 +180,8 @@ protected string ResolveHost() [SetUpFixture] public class TestEnvironment { + private static readonly SFLogger s_logger = SFLoggerFactory.GetLogger(); + private const string ConnectionStringFmt = "scheme={0};host={1};port={2};" + "account={3};role={4};db={5};warehouse={6};user={7};password={8};"; @@ -197,7 +202,7 @@ public static void RecordTestPerformance(string name, TimeSpan time) [OneTimeSetUp] public void Setup() { - Console.WriteLine("one time setup"); + s_logger.Debug("one time setup"); #if NETFRAMEWORK log4net.GlobalContext.Properties["framework"] = "net471"; @@ -254,7 +259,7 @@ public void SetupTestPerformance() [OneTimeTearDown] public void CreateTestTimeArtifact() { - Console.WriteLine("CREATE TIME"); + s_logger.Debug("CREATE TIME"); var resultText = "test;time_in_ms\n"; resultText += string.Join("\n", @@ -291,7 +296,7 @@ private static void ModifySchema(string schemaName, SchemaAction schemaAction) { using (IDbConnection conn = new SnowflakeDbConnection()) { - Console.WriteLine("MODIFY SCHEMA"); + s_logger.Debug("MODIFY SCHEMA"); conn.ConnectionString = s_connectionString; conn.Open(); @@ -323,19 +328,19 @@ private static string GetOs() { if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { - Console.WriteLine("WIN"); + s_logger.Debug("WIN"); return "windows"; } if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) { - Console.WriteLine("LIN"); + s_logger.Debug("LIN"); return "linux"; } if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) { - Console.WriteLine("MACOS"); + s_logger.Debug("MACOS"); return "macos"; } From 120d396f691c1582551f65bd5799c4a4a748356a Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Tue, 28 Jan 2025 11:36:01 +0100 Subject: [PATCH 15/41] more params, edited jenkinsfile --- Jenkinsfile | 20 ++++++++------------ 1 file changed, 8 insertions(+), 12 deletions(-) diff --git a/Jenkinsfile b/Jenkinsfile index d4fd81e66..5a468998f 100644 --- a/Jenkinsfile +++ b/Jenkinsfile @@ -35,22 +35,18 @@ timestamps { stage('Test') { parallel( - 'Test': { - stage('Test') { - build job: 'RT-LanguageDotnet-PC', parameters: params - } - }, 'Test Authentication': { stage('Test Authentication') { - agent { - docker { - image 'dotnet-centos7-net6' - args '-u root:root' - } - } withCredentials([ string(credentialsId: 'a791118f-a1ea-46cd-b876-56da1b9bc71c', variable: 'NEXUS_PASSWORD'), - string(credentialsId: 'sfctest0-parameters-secret', variable: 'PARAMETERS_SECRET') + string(credentialsId: 'sfctest0-parameters-secret', variable: 'PARAMETERS_SECRET'), + string(name: 'svn_revision', value: 'bptp-built'), + string(name: 'branch', value: 'main'), + string(name: 'client_git_commit', value: scmInfo.GIT_COMMIT), + string(name: 'client_git_branch', value: scmInfo.GIT_BRANCH), + string(name: 'TARGET_DOCKER_TEST_IMAGE', value: 'dotnet-ubuntu204-net9'), + string(name: 'parent_job', value: env.JOB_NAME), + string(name: 'parent_build_number', value: env.BUILD_NUMBER) ]) { sh '''\ |#!/bin/bash -e From 97d933640df46f3c66b1fa2387d752035a20499b Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Tue, 28 Jan 2025 11:42:10 +0100 Subject: [PATCH 16/41] fixjenkins --- Jenkinsfile | 7 ------- 1 file changed, 7 deletions(-) diff --git a/Jenkinsfile b/Jenkinsfile index 5a468998f..64dcf7ac3 100644 --- a/Jenkinsfile +++ b/Jenkinsfile @@ -40,13 +40,6 @@ timestamps { withCredentials([ string(credentialsId: 'a791118f-a1ea-46cd-b876-56da1b9bc71c', variable: 'NEXUS_PASSWORD'), string(credentialsId: 'sfctest0-parameters-secret', variable: 'PARAMETERS_SECRET'), - string(name: 'svn_revision', value: 'bptp-built'), - string(name: 'branch', value: 'main'), - string(name: 'client_git_commit', value: scmInfo.GIT_COMMIT), - string(name: 'client_git_branch', value: scmInfo.GIT_BRANCH), - string(name: 'TARGET_DOCKER_TEST_IMAGE', value: 'dotnet-ubuntu204-net9'), - string(name: 'parent_job', value: env.JOB_NAME), - string(name: 'parent_build_number', value: env.BUILD_NUMBER) ]) { sh '''\ |#!/bin/bash -e From e2d194b648b3e2e978ccf6ae00119920972442ca Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Tue, 28 Jan 2025 11:49:43 +0100 Subject: [PATCH 17/41] cleanup jenkins --- Jenkinsfile | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/Jenkinsfile b/Jenkinsfile index 64dcf7ac3..4d474b555 100644 --- a/Jenkinsfile +++ b/Jenkinsfile @@ -35,11 +35,16 @@ timestamps { stage('Test') { parallel( + 'Test': { + stage('Test') { + build job: 'RT-LanguageDotnet-PC', parameters: params + } + }, 'Test Authentication': { stage('Test Authentication') { withCredentials([ string(credentialsId: 'a791118f-a1ea-46cd-b876-56da1b9bc71c', variable: 'NEXUS_PASSWORD'), - string(credentialsId: 'sfctest0-parameters-secret', variable: 'PARAMETERS_SECRET'), + string(credentialsId: 'sfctest0-parameters-secret', variable: 'PARAMETERS_SECRET') ]) { sh '''\ |#!/bin/bash -e From 3e3bc2137820f2d8ad687857898721268ed2de7a Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Tue, 28 Jan 2025 12:14:08 +0100 Subject: [PATCH 18/41] without basetest --- Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs index 18b4e6632..87b69633b 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs @@ -13,7 +13,7 @@ namespace Snowflake.Data.Tests.AuthenticationTests { [NonParallelizable] - public class KeyPairConnectionTest : SFBaseTest + public class KeyPairConnectionTest { private string _connectionString = ""; @@ -23,7 +23,6 @@ public class KeyPairConnectionTest : SFBaseTest public void TestAuthenticateUsingKeyPairFileContentSuccessful() { - s_logger.Debug("Before test, after setup"); Console.WriteLine("Before test, after setup"); AuthTestHelper authTestHelper = new AuthTestHelper(); var privateKey = AuthConnectionString.GetPrivateKeyContentForKeypairAuth("SNOWFLAKE_AUTH_TEST_PRIVATE_KEY_PATH"); From e95071fecfa031a17246710c77a136488338f39d Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Tue, 28 Jan 2025 14:36:56 +0100 Subject: [PATCH 19/41] without fixtures --- .../AuthenticationTests/KeyPairConnection.cs | 84 +++++++++---------- Snowflake.Data.Tests/SFBaseTest.cs | 84 ++++++++++--------- ci/container/test_authentication.sh | 1 + 3 files changed, 83 insertions(+), 86 deletions(-) diff --git a/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs index 87b69633b..036513ae4 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs @@ -4,11 +4,6 @@ using System; using NUnit.Framework; -using NUnit.Framework.Internal; -using Snowflake.Data.Log; - - - namespace Snowflake.Data.Tests.AuthenticationTests { @@ -17,7 +12,6 @@ public class KeyPairConnectionTest { private string _connectionString = ""; - private static readonly SFLogger s_logger = SFLoggerFactory.GetLogger(); [Test, IgnoreOnCI] public void TestAuthenticateUsingKeyPairFileContentSuccessful() @@ -28,48 +22,46 @@ public void TestAuthenticateUsingKeyPairFileContentSuccessful() var privateKey = AuthConnectionString.GetPrivateKeyContentForKeypairAuth("SNOWFLAKE_AUTH_TEST_PRIVATE_KEY_PATH"); var parameters = AuthConnectionString.GetKeyPairFromFileContentParameters(privateKey); _connectionString = AuthConnectionString.SetPrivateKeyFromFileContentConnectionString(parameters); - s_logger.Debug(_connectionString); authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); authTestHelper.VerifyExceptionIsNotThrown(); } -// // -// // [Test, IgnoreOnCI] -// // public void TestAuthenticateUsingKeyPairFileContentInvalidKey() -// // { -// // AuthTestHelper authTestHelper = new AuthTestHelper(); -// // -// // var privateKey = AuthConnectionString.GetPrivateKeyContentForKeypairAuth("SNOWFLAKE_AUTH_TEST_INVALID_PRIVATE_KEY_PATH"); -// // var parameters = AuthConnectionString.GetKeyPairFromFileContentParameters(privateKey); -// // _connectionString = AuthConnectionString.SetPrivateKeyFromFileContentConnectionString(parameters); -// // -// // authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); -// // authTestHelper.VerifyExceptionIsThrown("Error: JWT token is invalid"); -// // } -// // -// // [Test, IgnoreOnCI] -// // public void TestAuthenticateUsingKeyPairFilePathSuccessful() -// // { -// // AuthTestHelper authTestHelper = new AuthTestHelper(); -// // -// // var privateKeyPath = AuthConnectionString.GetPrivateKeyPathForKeypairAuth("SNOWFLAKE_AUTH_TEST_PRIVATE_KEY_PATH"); -// // var parameters = AuthConnectionString.GetKeyPairFromFilePathConnectionString(privateKeyPath); -// // _connectionString = AuthConnectionString.SetPrivateKeyFromFilePathConnectionString(parameters); -// // -// // authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); -// // authTestHelper.VerifyExceptionIsNotThrown(); -// // } -// // -// // [Test, IgnoreOnCI] -// // public void TestAuthenticateUsingKeyPairFilePathInvalidKey() -// // { -// // AuthTestHelper authTestHelper = new AuthTestHelper(); -// // -// // var privateKeyPath = AuthConnectionString.GetPrivateKeyPathForKeypairAuth("SNOWFLAKE_AUTH_TEST_INVALID_PRIVATE_KEY_PATH"); -// // var parameters = AuthConnectionString.GetKeyPairFromFilePathConnectionString(privateKeyPath); -// // _connectionString = AuthConnectionString.SetPrivateKeyFromFilePathConnectionString(parameters); -// // -// // authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); -// // authTestHelper.VerifyExceptionIsThrown("Error: JWT token is invalid"); -// // } + + [Test, IgnoreOnCI] + public void TestAuthenticateUsingKeyPairFileContentInvalidKey() + { + AuthTestHelper authTestHelper = new AuthTestHelper(); + + var privateKey = AuthConnectionString.GetPrivateKeyContentForKeypairAuth("SNOWFLAKE_AUTH_TEST_INVALID_PRIVATE_KEY_PATH"); + var parameters = AuthConnectionString.GetKeyPairFromFileContentParameters(privateKey); + _connectionString = AuthConnectionString.SetPrivateKeyFromFileContentConnectionString(parameters); + + authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); + authTestHelper.VerifyExceptionIsThrown("Error: JWT token is invalid"); + } + + [Test, IgnoreOnCI] + public void TestAuthenticateUsingKeyPairFilePathSuccessful() + { + AuthTestHelper authTestHelper = new AuthTestHelper(); + var privateKeyPath = AuthConnectionString.GetPrivateKeyPathForKeypairAuth("SNOWFLAKE_AUTH_TEST_PRIVATE_KEY_PATH"); + var parameters = AuthConnectionString.GetKeyPairFromFilePathConnectionString(privateKeyPath); + _connectionString = AuthConnectionString.SetPrivateKeyFromFilePathConnectionString(parameters); + + authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); + authTestHelper.VerifyExceptionIsNotThrown(); + } + + [Test, IgnoreOnCI] + public void TestAuthenticateUsingKeyPairFilePathInvalidKey() + { + AuthTestHelper authTestHelper = new AuthTestHelper(); + + var privateKeyPath = AuthConnectionString.GetPrivateKeyPathForKeypairAuth("SNOWFLAKE_AUTH_TEST_INVALID_PRIVATE_KEY_PATH"); + var parameters = AuthConnectionString.GetKeyPairFromFilePathConnectionString(privateKeyPath); + _connectionString = AuthConnectionString.SetPrivateKeyFromFilePathConnectionString(parameters); + + authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); + authTestHelper.VerifyExceptionIsThrown("Error: JWT token is invalid"); + } } } diff --git a/Snowflake.Data.Tests/SFBaseTest.cs b/Snowflake.Data.Tests/SFBaseTest.cs index 20cc88bdd..0c4db5c94 100755 --- a/Snowflake.Data.Tests/SFBaseTest.cs +++ b/Snowflake.Data.Tests/SFBaseTest.cs @@ -32,13 +32,12 @@ namespace Snowflake.Data.Tests [TestFixture] public class SFBaseTest : SFBaseTestAsync { - private static readonly SFLogger s_logger = SFLoggerFactory.GetLogger(); [SetUp] public static void SetUpContext() { - s_logger.Debug("Setup context"); - s_logger.Debug("Setup context"); + + Console.WriteLine("Setup context"); MockSynchronizationContext.SetupContext(); } @@ -79,7 +78,7 @@ public class SFBaseTestAsync [SetUp] public void BeforeTest() { - s_logger.Debug("BEFORE TEST METHOD"); + Console.WriteLine("BEFORE TEST METHOD"); _stopwatch = new Stopwatch(); _stopwatch.Start(); @@ -89,7 +88,7 @@ public void BeforeTest() [TearDown] public void AfterTest() { - s_logger.Debug("AFTER TEST METHOD"); + Console.WriteLine("AFTER TEST METHOD"); _stopwatch.Stop(); var testName = $"{TestContext.CurrentContext.Test.FullName}"; @@ -100,7 +99,7 @@ public void AfterTest() private void RemoveTables() { - s_logger.Debug("REMOVE TABLE TEST METHOD"); + Console.WriteLine("REMOVE TABLE TEST METHOD"); if (_tablesToRemove.Count == 0) return; @@ -121,7 +120,7 @@ private void RemoveTables() protected void CreateOrReplaceTable(IDbConnection conn, string tableName, IEnumerable columns, string additionalQueryStr = null) { - s_logger.Debug("CREATE OR REPLACE"); + Console.WriteLine("CREATE OR REPLACE"); CreateOrReplaceTable(conn, tableName, "", columns, additionalQueryStr); } @@ -144,7 +143,7 @@ protected void AddTableToRemoveList(string tableName) public SFBaseTestAsync() { - s_logger.Debug("TEST CONFIG SETUP"); + Console.WriteLine("TEST CONFIG SETUP"); testConfig = TestEnvironment.TestConfig; } @@ -180,8 +179,6 @@ protected string ResolveHost() [SetUpFixture] public class TestEnvironment { - private static readonly SFLogger s_logger = SFLoggerFactory.GetLogger(); - private const string ConnectionStringFmt = "scheme={0};host={1};port={2};" + "account={3};role={4};db={5};warehouse={6};user={7};password={8};"; @@ -202,8 +199,6 @@ public static void RecordTestPerformance(string name, TimeSpan time) [OneTimeSetUp] public void Setup() { - s_logger.Debug("one time setup"); - #if NETFRAMEWORK log4net.GlobalContext.Properties["framework"] = "net471"; log4net.Config.XmlConfigurator.Configure(); @@ -213,41 +208,50 @@ public void Setup() var logRepository = log4net.LogManager.GetRepository(Assembly.GetEntryAssembly()); log4net.Config.XmlConfigurator.Configure(logRepository, new FileInfo("App.config")); #endif - var cloud = Environment.GetEnvironmentVariable("snowflake_cloud_env"); - Assert.IsTrue(cloud == null || cloud == "AWS" || cloud == "AZURE" || cloud == "GCP", "{0} is not supported. Specify AWS, AZURE or GCP as cloud environment", cloud); + var skipFixtures = Environment.GetEnvironmentVariable("SKIP_ONETIME_FIXTURES"); + if (string.IsNullOrEmpty(skipFixtures) || skipFixtures.ToLower() == "false") + { + var cloud = Environment.GetEnvironmentVariable("snowflake_cloud_env"); + Assert.IsTrue(cloud == null || cloud == "AWS" || cloud == "AZURE" || cloud == "GCP", + "{0} is not supported. Specify AWS, AZURE or GCP as cloud environment", cloud); - var reader = new StreamReader("parameters.json"); + var reader = new StreamReader("parameters.json"); - var testConfigString = reader.ReadToEnd(); + var testConfigString = reader.ReadToEnd(); - // Local JSON settings to avoid using system wide settings which could be different - // than the default ones - var jsonSettings = new JsonSerializerSettings - { - ContractResolver = new DefaultContractResolver + // Local JSON settings to avoid using system wide settings which could be different + // than the default ones + var jsonSettings = new JsonSerializerSettings + { + ContractResolver = new DefaultContractResolver + { + NamingStrategy = new DefaultNamingStrategy() + } + }; + var testConfigs = JsonConvert.DeserializeObject>(testConfigString, jsonSettings); + + if (testConfigs.TryGetValue("testconnection", out var testConnectionConfig)) + { + TestConfig = testConnectionConfig; + TestConfig.schema = TestConfig.schema + "_" + Guid.NewGuid().ToString().Replace("-", "_"); + } + else { - NamingStrategy = new DefaultNamingStrategy() + Assert.Fail("Failed to load test configuration"); } - }; - var testConfigs = JsonConvert.DeserializeObject>(testConfigString, jsonSettings); - if (testConfigs.TryGetValue("testconnection", out var testConnectionConfig)) - { - TestConfig = testConnectionConfig; - TestConfig.schema = TestConfig.schema + "_" + Guid.NewGuid().ToString().Replace("-", "_"); - } - else - { - Assert.Fail("Failed to load test configuration"); + ModifySchema(TestConfig.schema, SchemaAction.CREATE); } - - ModifySchema(TestConfig.schema, SchemaAction.CREATE); } [OneTimeTearDown] public void Cleanup() { - ModifySchema(TestConfig.schema, SchemaAction.DROP); + var skipFixtures = Environment.GetEnvironmentVariable("SKIP_ONETIME_FIXTURES"); + if (string.IsNullOrEmpty(skipFixtures) || skipFixtures.ToLower() == "false") + { + ModifySchema(TestConfig.schema, SchemaAction.DROP); + } } [OneTimeSetUp] @@ -259,7 +263,7 @@ public void SetupTestPerformance() [OneTimeTearDown] public void CreateTestTimeArtifact() { - s_logger.Debug("CREATE TIME"); + Console.WriteLine("CREATE TIME"); var resultText = "test;time_in_ms\n"; resultText += string.Join("\n", @@ -296,7 +300,7 @@ private static void ModifySchema(string schemaName, SchemaAction schemaAction) { using (IDbConnection conn = new SnowflakeDbConnection()) { - s_logger.Debug("MODIFY SCHEMA"); + Console.WriteLine("MODIFY SCHEMA"); conn.ConnectionString = s_connectionString; conn.Open(); @@ -328,19 +332,19 @@ private static string GetOs() { if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { - s_logger.Debug("WIN"); + Console.WriteLine("WIN"); return "windows"; } if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) { - s_logger.Debug("LIN"); + Console.WriteLine("LIN"); return "linux"; } if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) { - s_logger.Debug("MACOS"); + Console.WriteLine("MACOS"); return "macos"; } diff --git a/ci/container/test_authentication.sh b/ci/container/test_authentication.sh index 9cdc966d4..287a55c49 100755 --- a/ci/container/test_authentication.sh +++ b/ci/container/test_authentication.sh @@ -11,5 +11,6 @@ eval $(jq -r '.authtestparams | to_entries | map("export \(.key)=\(.value|tostri export SNOWFLAKE_AUTH_TEST_PRIVATE_KEY_PATH=./.github/workflows/parameters/rsa_keys/rsa_key.p8 export SNOWFLAKE_AUTH_TEST_INVALID_PRIVATE_KEY_PATH=./.github/workflows/parameters/rsa_keys/rsa_key_invalid.p8 +export SKIP_ONETIME_FIXTURES=true dotnet test -l "console;verbosity=diagnostic" --filter FullyQualifiedName~AuthenticationTests From 4eece68af5363e91db0d24d01920d6ccf6bc7ab1 Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Tue, 28 Jan 2025 15:34:58 +0100 Subject: [PATCH 20/41] creating parameters.json --- .../parameters_aws_auth_tests.json.gpg | Bin 859 -> 941 bytes Snowflake.Data.Tests/SFBaseTest.cs | 37 +----------------- ci/container/test_authentication.sh | 10 ++++- 3 files changed, 11 insertions(+), 36 deletions(-) diff --git a/.github/workflows/parameters/parameters_aws_auth_tests.json.gpg b/.github/workflows/parameters/parameters_aws_auth_tests.json.gpg index 73e16bc4284d5ae1dc3ab82be4e16364b2e38c37..9d4dfad092efb29cb58fbd0538dd0d9229b4b149 100644 GIT binary patch literal 941 zcmV;e15*5q4Fm}T2%1l9B&;z{$^X*n0aIYEp6sUloqGp+W;+|rz$`bZ0ouIzYU*~j z`nT5XZw{I>R`+XKS;TkwkV6q@=2|92c>!p68B`+qR^2=--pMR9q-^ZL;+I+ZC`EVR z7OZQ)$JDkrIl!|LX}r*~Y_9nMjmWY)PG8h)>D{v}Gh(K&|9=$>+K7*;D19bqyV%i| zOCE*zWkwBji+MJCuij*cY26WhU6U6bhK33P`kigVthP$A6M)qkc&emcN>cN&eW;Q% zlQ{+F{4wwnm@g!?*i*0mD)z61&=HrtM>+i7A|)&#YOE%D}2 zS{$HI_9eaDoavjh3!`=OD9l=kNK!mrkrc_ajG{to7)LHSJpKssr_jK;XNQN9=SzU} zb531otN%iPs`tt%Fy8ZeGw1^!GT!PVPgv2(60Wx+*3_4;vIX-c3 zN5!Jx5*)kb0~Wz2Nd?EK*Sovn1{9L-s8-qQyzNc|6TjDsi#1Eg$ma3%h?UMY_hLgQ zJ1DSe8^@>MK!jg>*g@v!$+Xu1R|^aEN?M~i-eZu8xVsAy1V^{YC#TZI{v~?UZ)-9Y z3F1P?VgTii7*T(2xWn-q-=meT>$YTqBwHV1=mH3j@m46~yp1a-ge!6^r(g8i!f5zw zj3xg9;e*q&e;Z5_d6+TX$Sesi4jGm@X2pDt_!z5ge zQ4*~60gOH*SS zBZ+>qP$^{dX_2YpV=PFTE+CCCWVeP`1F09w5PvNG8Z;ISc}G3;$LZr$oU6RpO6ArtgaG&W4JbmIf41B0?fQpMR-f=~Iq57Kv)bm;R_5U=*Yi~_gR#tbl>=RvD zhWMIh1HREY-p&s9qNXv`sy!J`FekObQulI7axxoBUyC@lA92Zp&JR#Vc7hdLzzOV8 zo={))Hc~S~hu5t$fJ7n><8cKig0BG5p5*EzcdsR8uX4Pyp(Rci=L6b}fS0+xLXRF& zL$9IBQgW_bFjN$yzP|C;nP4sQ1hm%vup!>37CcVJ!lIogne~)u3_5_}>UVsQ?gk0$UK? za!$jvki)5n*AJ(F!@@UMA1#1l8l*QH(LAchrCk^tC9Wgz=ktpPe*)tQR&V-hCGT5-^dg~G44z;uf~!$R;jqO2OxB0Sca`P+{Rny%G8*uZaN%liCDQt$&_y{;2tr;yrPL6b$LKiC< zG%A9*(h3Bb6xh{_?M3Bqz=*cn;!r!5!LH4gTIU56MA6dF(wP?4`icDbwwwU)lata(7h?HFU;Ft0#JT3V27F}2fKK0JGvd)-e;s$voNfd0q4UkI=W^l0tA)toFQmjQ;A^=sAUEI%-{gxA)O- z&Heq=G3#sv6=Zu{fP#7=!KW;>EFwg0sDY`L=|m{hT+n7j06_Dim6=VK$p^;s$k8FA zDL9{S`qO1I<;=1sZKi2|{b5x9ER3dU!{bO#H=Q`;=h%u8G~_(); @@ -88,8 +82,6 @@ public void BeforeTest() [TearDown] public void AfterTest() { - Console.WriteLine("AFTER TEST METHOD"); - _stopwatch.Stop(); var testName = $"{TestContext.CurrentContext.Test.FullName}"; @@ -99,8 +91,6 @@ public void AfterTest() private void RemoveTables() { - Console.WriteLine("REMOVE TABLE TEST METHOD"); - if (_tablesToRemove.Count == 0) return; @@ -120,8 +110,6 @@ private void RemoveTables() protected void CreateOrReplaceTable(IDbConnection conn, string tableName, IEnumerable columns, string additionalQueryStr = null) { - Console.WriteLine("CREATE OR REPLACE"); - CreateOrReplaceTable(conn, tableName, "", columns, additionalQueryStr); } @@ -143,8 +131,6 @@ protected void AddTableToRemoveList(string tableName) public SFBaseTestAsync() { - Console.WriteLine("TEST CONFIG SETUP"); - testConfig = TestEnvironment.TestConfig; } @@ -208,12 +194,8 @@ public void Setup() var logRepository = log4net.LogManager.GetRepository(Assembly.GetEntryAssembly()); log4net.Config.XmlConfigurator.Configure(logRepository, new FileInfo("App.config")); #endif - var skipFixtures = Environment.GetEnvironmentVariable("SKIP_ONETIME_FIXTURES"); - if (string.IsNullOrEmpty(skipFixtures) || skipFixtures.ToLower() == "false") - { var cloud = Environment.GetEnvironmentVariable("snowflake_cloud_env"); - Assert.IsTrue(cloud == null || cloud == "AWS" || cloud == "AZURE" || cloud == "GCP", - "{0} is not supported. Specify AWS, AZURE or GCP as cloud environment", cloud); + Assert.IsTrue(cloud == null || cloud == "AWS" || cloud == "AZURE" || cloud == "GCP", "{0} is not supported. Specify AWS, AZURE or GCP as cloud environment", cloud); var reader = new StreamReader("parameters.json"); @@ -241,17 +223,12 @@ public void Setup() } ModifySchema(TestConfig.schema, SchemaAction.CREATE); - } } [OneTimeTearDown] public void Cleanup() { - var skipFixtures = Environment.GetEnvironmentVariable("SKIP_ONETIME_FIXTURES"); - if (string.IsNullOrEmpty(skipFixtures) || skipFixtures.ToLower() == "false") - { - ModifySchema(TestConfig.schema, SchemaAction.DROP); - } + ModifySchema(TestConfig.schema, SchemaAction.DROP); } [OneTimeSetUp] @@ -263,8 +240,6 @@ public void SetupTestPerformance() [OneTimeTearDown] public void CreateTestTimeArtifact() { - Console.WriteLine("CREATE TIME"); - var resultText = "test;time_in_ms\n"; resultText += string.Join("\n", s_testPerformance.Select(test => $"{test.Key};{Math.Round(test.Value.TotalMilliseconds,0)}")); @@ -300,8 +275,6 @@ private static void ModifySchema(string schemaName, SchemaAction schemaAction) { using (IDbConnection conn = new SnowflakeDbConnection()) { - Console.WriteLine("MODIFY SCHEMA"); - conn.ConnectionString = s_connectionString; conn.Open(); var dbCommand = conn.CreateCommand(); @@ -332,20 +305,14 @@ private static string GetOs() { if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { - Console.WriteLine("WIN"); - return "windows"; } if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) { - Console.WriteLine("LIN"); - return "linux"; } if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) { - Console.WriteLine("MACOS"); - return "macos"; } diff --git a/ci/container/test_authentication.sh b/ci/container/test_authentication.sh index 287a55c49..f8b7e9040 100755 --- a/ci/container/test_authentication.sh +++ b/ci/container/test_authentication.sh @@ -11,6 +11,14 @@ eval $(jq -r '.authtestparams | to_entries | map("export \(.key)=\(.value|tostri export SNOWFLAKE_AUTH_TEST_PRIVATE_KEY_PATH=./.github/workflows/parameters/rsa_keys/rsa_key.p8 export SNOWFLAKE_AUTH_TEST_INVALID_PRIVATE_KEY_PATH=./.github/workflows/parameters/rsa_keys/rsa_key_invalid.p8 -export SKIP_ONETIME_FIXTURES=true + +PARAMETERS_JSON="./Snowflake.Data.Tests/parameters.json" +echo '{ "testconnection": {' > $PARAMETERS_JSON +env | grep '^SNOWFLAKE_TEST' | while IFS='=' read -r key value; do + echo " \"$key\": \"$value\"," >> $PARAMETERS_JSON +done +# Remove the last comma and close the JSON object +awk '{if (NR>1) print prev; prev=$0} END {sub(/,$/, "", prev); print prev}' $PARAMETERS_JSON > tmp && mv tmp $PARAMETERS_JSON +echo '}}' >> $PARAMETERS_JSON dotnet test -l "console;verbosity=diagnostic" --filter FullyQualifiedName~AuthenticationTests From 913e2ec140fe378414f3f12c29a6a16b36269e13 Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Tue, 28 Jan 2025 15:43:06 +0100 Subject: [PATCH 21/41] different test set --- .../ExternalBrowserConnection.cs | 198 +++++++++--------- .../AuthenticationTests/KeyPairConnection.cs | 134 ++++++------ .../AuthenticationTests/OauthConnection.cs | 70 +++---- 3 files changed, 201 insertions(+), 201 deletions(-) diff --git a/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs index e050e6091..adb4e1c71 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs @@ -1,99 +1,99 @@ -// /* -// * Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved. -// */ -// -// using System.Threading; -// using NUnit.Framework; -// using Snowflake.Data.Core; -// -// namespace Snowflake.Data.Tests.AuthenticationTests -// { -// -// [NonParallelizable] -// public class ExternalBrowserConnectionTest : SFBaseTest -// { -// private string _connectionString = ""; -// private string _login = AuthConnectionString.SsoUser; -// private string _password = AuthConnectionString.SsoPassword; -// -// [SetUp] -// public void SetUp() -// { -// AuthTestHelper authTestHelper = new AuthTestHelper(); -// _login = AuthConnectionString.SsoUser; -// _password = AuthConnectionString.SsoPassword; -// authTestHelper.CleanBrowserProcess(); -// var parameters = AuthConnectionString.GetExternalBrowserConnectionString(); -// _connectionString = AuthConnectionString.SetExternalBrowserConnectionString(parameters); -// } -// -// [Test, IgnoreOnCI] -// public void TestAuthenticateUsingExternalBrowserSuccessful() -// { -// AuthTestHelper authTestHelper = new AuthTestHelper(); -// -// Thread connectThread = authTestHelper.GetConnectAndExecuteSimpleQueryThread(_connectionString); -// Thread provideCredentialsThread = authTestHelper.GetProvideCredentialsThread("success", _login, _password); -// -// authTestHelper.ConnectAndProvideCredentials(provideCredentialsThread, connectThread); -// authTestHelper.VerifyExceptionIsNotThrown(); -// -// } -// -// [Test, IgnoreOnCI] -// public void TestAuthenticateUsingExternalBrowserMismatchedUser() -// { -// AuthTestHelper authTestHelper = new AuthTestHelper(); -// -// var parameters = AuthConnectionString.GetExternalBrowserConnectionString(); -// parameters[SFSessionProperty.USER] = "differentUser"; -// -// _connectionString = AuthConnectionString.SetExternalBrowserConnectionString(parameters); -// -// Thread connectThread = authTestHelper.GetConnectAndExecuteSimpleQueryThread(_connectionString); -// Thread provideCredentialsThread = authTestHelper.GetProvideCredentialsThread("success", _login, _password); -// -// authTestHelper.ConnectAndProvideCredentials(provideCredentialsThread, connectThread); -// authTestHelper.VerifyExceptionIsThrown("The user you were trying to authenticate as differs from the user currently logged in at the IDP"); -// -// } -// -// [Test, IgnoreOnCI] -// public void TestAuthenticateUsingExternalBrowserWrongCredentials() -// { -// AuthTestHelper authTestHelper = new AuthTestHelper(); -// -// var parameters = AuthConnectionString.GetExternalBrowserConnectionString(); -// -// _connectionString = AuthConnectionString.SetExternalBrowserConnectionString(parameters); -// _connectionString += "BROWSER_RESPONSE_TIMEOUT=15;"; -// -// _login = "itsnotanaccount.com"; -// _password = "fakepassword"; -// -// Thread connectThread = authTestHelper.GetConnectAndExecuteSimpleQueryThread(_connectionString); -// Thread provideCredentialsThread = authTestHelper.GetProvideCredentialsThread("fail", _login, _password); -// -// authTestHelper.ConnectAndProvideCredentials(provideCredentialsThread, connectThread); -// authTestHelper.VerifyExceptionIsThrown("Browser response timed out after 15 seconds"); -// -// } -// -// [Test, IgnoreOnCI] -// public void TestAuthenticateUsingExternalBrowserTimeout() -// { -// AuthTestHelper authTestHelper = new AuthTestHelper(); -// -// var parameters = AuthConnectionString.GetExternalBrowserConnectionString(); -// -// _connectionString = AuthConnectionString.SetExternalBrowserConnectionString(parameters); -// _connectionString += "BROWSER_RESPONSE_TIMEOUT=1;"; -// -// Thread connectThread = authTestHelper.GetConnectAndExecuteSimpleQueryThread(_connectionString); -// Thread provideCredentialsThread = authTestHelper.GetProvideCredentialsThread("timeout", _login, _password); -// -// authTestHelper.ConnectAndProvideCredentials(provideCredentialsThread, connectThread); -// authTestHelper.VerifyExceptionIsThrown("Browser response timed out after 1 seconds"); -// } -// } -// } +/* + * Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved. + */ + +using System.Threading; +using NUnit.Framework; +using Snowflake.Data.Core; + +namespace Snowflake.Data.Tests.AuthenticationTests +{ + + [NonParallelizable] + public class ExternalBrowserConnectionTest : SFBaseTest + { + private string _connectionString = ""; + private string _login = AuthConnectionString.SsoUser; + private string _password = AuthConnectionString.SsoPassword; + + [SetUp] + public void SetUp() + { + AuthTestHelper authTestHelper = new AuthTestHelper(); + _login = AuthConnectionString.SsoUser; + _password = AuthConnectionString.SsoPassword; + authTestHelper.CleanBrowserProcess(); + var parameters = AuthConnectionString.GetExternalBrowserConnectionString(); + _connectionString = AuthConnectionString.SetExternalBrowserConnectionString(parameters); + } + + [Test, IgnoreOnCI] + public void TestAuthenticateUsingExternalBrowserSuccessful() + { + AuthTestHelper authTestHelper = new AuthTestHelper(); + + Thread connectThread = authTestHelper.GetConnectAndExecuteSimpleQueryThread(_connectionString); + Thread provideCredentialsThread = authTestHelper.GetProvideCredentialsThread("success", _login, _password); + + authTestHelper.ConnectAndProvideCredentials(provideCredentialsThread, connectThread); + authTestHelper.VerifyExceptionIsNotThrown(); + + } + // + // [Test, IgnoreOnCI] + // public void TestAuthenticateUsingExternalBrowserMismatchedUser() + // { + // AuthTestHelper authTestHelper = new AuthTestHelper(); + // + // var parameters = AuthConnectionString.GetExternalBrowserConnectionString(); + // parameters[SFSessionProperty.USER] = "differentUser"; + // + // _connectionString = AuthConnectionString.SetExternalBrowserConnectionString(parameters); + // + // Thread connectThread = authTestHelper.GetConnectAndExecuteSimpleQueryThread(_connectionString); + // Thread provideCredentialsThread = authTestHelper.GetProvideCredentialsThread("success", _login, _password); + // + // authTestHelper.ConnectAndProvideCredentials(provideCredentialsThread, connectThread); + // authTestHelper.VerifyExceptionIsThrown("The user you were trying to authenticate as differs from the user currently logged in at the IDP"); + // + // } + // + // [Test, IgnoreOnCI] + // public void TestAuthenticateUsingExternalBrowserWrongCredentials() + // { + // AuthTestHelper authTestHelper = new AuthTestHelper(); + // + // var parameters = AuthConnectionString.GetExternalBrowserConnectionString(); + // + // _connectionString = AuthConnectionString.SetExternalBrowserConnectionString(parameters); + // _connectionString += "BROWSER_RESPONSE_TIMEOUT=15;"; + // + // _login = "itsnotanaccount.com"; + // _password = "fakepassword"; + // + // Thread connectThread = authTestHelper.GetConnectAndExecuteSimpleQueryThread(_connectionString); + // Thread provideCredentialsThread = authTestHelper.GetProvideCredentialsThread("fail", _login, _password); + // + // authTestHelper.ConnectAndProvideCredentials(provideCredentialsThread, connectThread); + // authTestHelper.VerifyExceptionIsThrown("Browser response timed out after 15 seconds"); + // + // } + // + // [Test, IgnoreOnCI] + // public void TestAuthenticateUsingExternalBrowserTimeout() + // { + // AuthTestHelper authTestHelper = new AuthTestHelper(); + // + // var parameters = AuthConnectionString.GetExternalBrowserConnectionString(); + // + // _connectionString = AuthConnectionString.SetExternalBrowserConnectionString(parameters); + // _connectionString += "BROWSER_RESPONSE_TIMEOUT=1;"; + // + // Thread connectThread = authTestHelper.GetConnectAndExecuteSimpleQueryThread(_connectionString); + // Thread provideCredentialsThread = authTestHelper.GetProvideCredentialsThread("timeout", _login, _password); + // + // authTestHelper.ConnectAndProvideCredentials(provideCredentialsThread, connectThread); + // authTestHelper.VerifyExceptionIsThrown("Browser response timed out after 1 seconds"); + // } + } +} diff --git a/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs index 036513ae4..b555c357f 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs @@ -1,67 +1,67 @@ -/* - * Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved. - */ - -using System; -using NUnit.Framework; -namespace Snowflake.Data.Tests.AuthenticationTests -{ - - [NonParallelizable] - public class KeyPairConnectionTest - { - private string _connectionString = ""; - - - [Test, IgnoreOnCI] - public void TestAuthenticateUsingKeyPairFileContentSuccessful() - - { - Console.WriteLine("Before test, after setup"); - AuthTestHelper authTestHelper = new AuthTestHelper(); - var privateKey = AuthConnectionString.GetPrivateKeyContentForKeypairAuth("SNOWFLAKE_AUTH_TEST_PRIVATE_KEY_PATH"); - var parameters = AuthConnectionString.GetKeyPairFromFileContentParameters(privateKey); - _connectionString = AuthConnectionString.SetPrivateKeyFromFileContentConnectionString(parameters); - authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); - authTestHelper.VerifyExceptionIsNotThrown(); - } - - [Test, IgnoreOnCI] - public void TestAuthenticateUsingKeyPairFileContentInvalidKey() - { - AuthTestHelper authTestHelper = new AuthTestHelper(); - - var privateKey = AuthConnectionString.GetPrivateKeyContentForKeypairAuth("SNOWFLAKE_AUTH_TEST_INVALID_PRIVATE_KEY_PATH"); - var parameters = AuthConnectionString.GetKeyPairFromFileContentParameters(privateKey); - _connectionString = AuthConnectionString.SetPrivateKeyFromFileContentConnectionString(parameters); - - authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); - authTestHelper.VerifyExceptionIsThrown("Error: JWT token is invalid"); - } - - [Test, IgnoreOnCI] - public void TestAuthenticateUsingKeyPairFilePathSuccessful() - { - AuthTestHelper authTestHelper = new AuthTestHelper(); - var privateKeyPath = AuthConnectionString.GetPrivateKeyPathForKeypairAuth("SNOWFLAKE_AUTH_TEST_PRIVATE_KEY_PATH"); - var parameters = AuthConnectionString.GetKeyPairFromFilePathConnectionString(privateKeyPath); - _connectionString = AuthConnectionString.SetPrivateKeyFromFilePathConnectionString(parameters); - - authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); - authTestHelper.VerifyExceptionIsNotThrown(); - } - - [Test, IgnoreOnCI] - public void TestAuthenticateUsingKeyPairFilePathInvalidKey() - { - AuthTestHelper authTestHelper = new AuthTestHelper(); - - var privateKeyPath = AuthConnectionString.GetPrivateKeyPathForKeypairAuth("SNOWFLAKE_AUTH_TEST_INVALID_PRIVATE_KEY_PATH"); - var parameters = AuthConnectionString.GetKeyPairFromFilePathConnectionString(privateKeyPath); - _connectionString = AuthConnectionString.SetPrivateKeyFromFilePathConnectionString(parameters); - - authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); - authTestHelper.VerifyExceptionIsThrown("Error: JWT token is invalid"); - } - } -} +// /* +// * Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved. +// */ +// +// using System; +// using NUnit.Framework; +// namespace Snowflake.Data.Tests.AuthenticationTests +// { +// +// [NonParallelizable] +// public class KeyPairConnectionTest +// { +// private string _connectionString = ""; +// +// +// [Test, IgnoreOnCI] +// public void TestAuthenticateUsingKeyPairFileContentSuccessful() +// +// { +// Console.WriteLine("Before test, after setup"); +// AuthTestHelper authTestHelper = new AuthTestHelper(); +// var privateKey = AuthConnectionString.GetPrivateKeyContentForKeypairAuth("SNOWFLAKE_AUTH_TEST_PRIVATE_KEY_PATH"); +// var parameters = AuthConnectionString.GetKeyPairFromFileContentParameters(privateKey); +// _connectionString = AuthConnectionString.SetPrivateKeyFromFileContentConnectionString(parameters); +// authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); +// authTestHelper.VerifyExceptionIsNotThrown(); +// } +// +// [Test, IgnoreOnCI] +// public void TestAuthenticateUsingKeyPairFileContentInvalidKey() +// { +// AuthTestHelper authTestHelper = new AuthTestHelper(); +// +// var privateKey = AuthConnectionString.GetPrivateKeyContentForKeypairAuth("SNOWFLAKE_AUTH_TEST_INVALID_PRIVATE_KEY_PATH"); +// var parameters = AuthConnectionString.GetKeyPairFromFileContentParameters(privateKey); +// _connectionString = AuthConnectionString.SetPrivateKeyFromFileContentConnectionString(parameters); +// +// authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); +// authTestHelper.VerifyExceptionIsThrown("Error: JWT token is invalid"); +// } +// +// [Test, IgnoreOnCI] +// public void TestAuthenticateUsingKeyPairFilePathSuccessful() +// { +// AuthTestHelper authTestHelper = new AuthTestHelper(); +// var privateKeyPath = AuthConnectionString.GetPrivateKeyPathForKeypairAuth("SNOWFLAKE_AUTH_TEST_PRIVATE_KEY_PATH"); +// var parameters = AuthConnectionString.GetKeyPairFromFilePathConnectionString(privateKeyPath); +// _connectionString = AuthConnectionString.SetPrivateKeyFromFilePathConnectionString(parameters); +// +// authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); +// authTestHelper.VerifyExceptionIsNotThrown(); +// } +// +// [Test, IgnoreOnCI] +// public void TestAuthenticateUsingKeyPairFilePathInvalidKey() +// { +// AuthTestHelper authTestHelper = new AuthTestHelper(); +// +// var privateKeyPath = AuthConnectionString.GetPrivateKeyPathForKeypairAuth("SNOWFLAKE_AUTH_TEST_INVALID_PRIVATE_KEY_PATH"); +// var parameters = AuthConnectionString.GetKeyPairFromFilePathConnectionString(privateKeyPath); +// _connectionString = AuthConnectionString.SetPrivateKeyFromFilePathConnectionString(parameters); +// +// authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); +// authTestHelper.VerifyExceptionIsThrown("Error: JWT token is invalid"); +// } +// } +// } diff --git a/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs index c40a6c593..040ed7553 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs @@ -1,36 +1,36 @@ -// /* -// * Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved. -// */ -// -// using NUnit.Framework; -// using Snowflake.Data.Core; -// -// namespace Snowflake.Data.Tests.AuthenticationTests -// { -// -// [NonParallelizable] -// public class OauthConnectionTest : SFBaseTest -// { -// private string _connectionString = ""; -// -// [SetUp] -// public void SetUp() -// { -// string token = AuthConnectionString.GetOauthToken(); -// var parameters = AuthConnectionString.GetOauthConnectionString(token); -// _connectionString = AuthConnectionString.SetOauthConnectionString(parameters); -// -// } -// -// // [Test, IgnoreOnCI] -// // public void TestAuthenticateUsingOauthSuccessful() -// // { -// // AuthTestHelper authTestHelper = new AuthTestHelper(); -// // -// // authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); -// // authTestHelper.VerifyExceptionIsNotThrown(); -// // } -// // +/* + * Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved. + */ + +using NUnit.Framework; +using Snowflake.Data.Core; + +namespace Snowflake.Data.Tests.AuthenticationTests +{ + + [NonParallelizable] + public class OauthConnectionTest : SFBaseTest + { + private string _connectionString = ""; + + [SetUp] + public void SetUp() + { + string token = AuthConnectionString.GetOauthToken(); + var parameters = AuthConnectionString.GetOauthConnectionString(token); + _connectionString = AuthConnectionString.SetOauthConnectionString(parameters); + + } + + [Test, IgnoreOnCI] + public void TestAuthenticateUsingOauthSuccessful() + { + AuthTestHelper authTestHelper = new AuthTestHelper(); + + authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); + authTestHelper.VerifyExceptionIsNotThrown(); + } + // // [Test, IgnoreOnCI] // // public void TestAuthenticateUsingOauthInvalidToken() // // { @@ -58,5 +58,5 @@ // // authTestHelper.VerifyExceptionIsThrown("The user you were trying to authenticate as differs from the user tied to the access token"); // // // // } -// } -// } + } +} From f924d25c1d37b562f21ecb7bec180e525b693f04 Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Tue, 28 Jan 2025 15:56:52 +0100 Subject: [PATCH 22/41] silent sfbasetest --- .../AuthenticationTests/KeyPairConnection.cs | 58 +++--- .../AuthenticationTests/OauthConnection.cs | 16 +- Snowflake.Data.Tests/SFBaseTest.cs | 178 +++++++++--------- ci/container/test_authentication.sh | 15 +- 4 files changed, 134 insertions(+), 133 deletions(-) diff --git a/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs index b555c357f..c35d79821 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs @@ -1,30 +1,30 @@ -// /* -// * Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved. -// */ -// -// using System; -// using NUnit.Framework; -// namespace Snowflake.Data.Tests.AuthenticationTests -// { -// -// [NonParallelizable] -// public class KeyPairConnectionTest -// { -// private string _connectionString = ""; -// -// -// [Test, IgnoreOnCI] -// public void TestAuthenticateUsingKeyPairFileContentSuccessful() -// -// { -// Console.WriteLine("Before test, after setup"); -// AuthTestHelper authTestHelper = new AuthTestHelper(); -// var privateKey = AuthConnectionString.GetPrivateKeyContentForKeypairAuth("SNOWFLAKE_AUTH_TEST_PRIVATE_KEY_PATH"); -// var parameters = AuthConnectionString.GetKeyPairFromFileContentParameters(privateKey); -// _connectionString = AuthConnectionString.SetPrivateKeyFromFileContentConnectionString(parameters); -// authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); -// authTestHelper.VerifyExceptionIsNotThrown(); -// } +/* + * Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved. + */ + +using System; +using NUnit.Framework; +namespace Snowflake.Data.Tests.AuthenticationTests +{ + + [NonParallelizable] + public class KeyPairConnectionTest + { + private string _connectionString = ""; + + + [Test, IgnoreOnCI] + public void TestAuthenticateUsingKeyPairFileContentSuccessful() + + { + Console.WriteLine("Before test, after setup"); + AuthTestHelper authTestHelper = new AuthTestHelper(); + var privateKey = AuthConnectionString.GetPrivateKeyContentForKeypairAuth("SNOWFLAKE_AUTH_TEST_PRIVATE_KEY_PATH"); + var parameters = AuthConnectionString.GetKeyPairFromFileContentParameters(privateKey); + _connectionString = AuthConnectionString.SetPrivateKeyFromFileContentConnectionString(parameters); + authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); + authTestHelper.VerifyExceptionIsNotThrown(); + } // // [Test, IgnoreOnCI] // public void TestAuthenticateUsingKeyPairFileContentInvalidKey() @@ -63,5 +63,5 @@ // authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); // authTestHelper.VerifyExceptionIsThrown("Error: JWT token is invalid"); // } -// } -// } + } +} diff --git a/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs index 040ed7553..6bdc89008 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs @@ -22,14 +22,14 @@ public void SetUp() } - [Test, IgnoreOnCI] - public void TestAuthenticateUsingOauthSuccessful() - { - AuthTestHelper authTestHelper = new AuthTestHelper(); - - authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); - authTestHelper.VerifyExceptionIsNotThrown(); - } + // [Test, IgnoreOnCI] + // public void TestAuthenticateUsingOauthSuccessful() + // { + // AuthTestHelper authTestHelper = new AuthTestHelper(); + // + // authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); + // authTestHelper.VerifyExceptionIsNotThrown(); + // } // // [Test, IgnoreOnCI] // // public void TestAuthenticateUsingOauthInvalidToken() diff --git a/Snowflake.Data.Tests/SFBaseTest.cs b/Snowflake.Data.Tests/SFBaseTest.cs index db209a87a..fb26a31f5 100755 --- a/Snowflake.Data.Tests/SFBaseTest.cs +++ b/Snowflake.Data.Tests/SFBaseTest.cs @@ -70,24 +70,24 @@ public class SFBaseTestAsync private Stopwatch _stopwatch; private List _tablesToRemove; - - [SetUp] - public void BeforeTest() - { - _stopwatch = new Stopwatch(); - _stopwatch.Start(); - _tablesToRemove = new List(); - } - - [TearDown] - public void AfterTest() - { - _stopwatch.Stop(); - var testName = $"{TestContext.CurrentContext.Test.FullName}"; - - TestEnvironment.RecordTestPerformance(testName, _stopwatch.Elapsed); - RemoveTables(); - } + // + // [SetUp] + // public void BeforeTest() + // { + // _stopwatch = new Stopwatch(); + // _stopwatch.Start(); + // _tablesToRemove = new List(); + // } + // + // [TearDown] + // public void AfterTest() + // { + // _stopwatch.Stop(); + // var testName = $"{TestContext.CurrentContext.Test.FullName}"; + // + // TestEnvironment.RecordTestPerformance(testName, _stopwatch.Elapsed); + // RemoveTables(); + // } private void RemoveTables() { @@ -182,77 +182,77 @@ public static void RecordTestPerformance(string name, TimeSpan time) } } - [OneTimeSetUp] - public void Setup() - { -#if NETFRAMEWORK - log4net.GlobalContext.Properties["framework"] = "net471"; - log4net.Config.XmlConfigurator.Configure(); - -#else - log4net.GlobalContext.Properties["framework"] = "net6.0"; - var logRepository = log4net.LogManager.GetRepository(Assembly.GetEntryAssembly()); - log4net.Config.XmlConfigurator.Configure(logRepository, new FileInfo("App.config")); -#endif - var cloud = Environment.GetEnvironmentVariable("snowflake_cloud_env"); - Assert.IsTrue(cloud == null || cloud == "AWS" || cloud == "AZURE" || cloud == "GCP", "{0} is not supported. Specify AWS, AZURE or GCP as cloud environment", cloud); - - var reader = new StreamReader("parameters.json"); - - var testConfigString = reader.ReadToEnd(); - - // Local JSON settings to avoid using system wide settings which could be different - // than the default ones - var jsonSettings = new JsonSerializerSettings - { - ContractResolver = new DefaultContractResolver - { - NamingStrategy = new DefaultNamingStrategy() - } - }; - var testConfigs = JsonConvert.DeserializeObject>(testConfigString, jsonSettings); - - if (testConfigs.TryGetValue("testconnection", out var testConnectionConfig)) - { - TestConfig = testConnectionConfig; - TestConfig.schema = TestConfig.schema + "_" + Guid.NewGuid().ToString().Replace("-", "_"); - } - else - { - Assert.Fail("Failed to load test configuration"); - } - - ModifySchema(TestConfig.schema, SchemaAction.CREATE); - } - - [OneTimeTearDown] - public void Cleanup() - { - ModifySchema(TestConfig.schema, SchemaAction.DROP); - } - - [OneTimeSetUp] - public void SetupTestPerformance() - { - s_testPerformance = new Dictionary(); - } - - [OneTimeTearDown] - public void CreateTestTimeArtifact() - { - var resultText = "test;time_in_ms\n"; - resultText += string.Join("\n", - s_testPerformance.Select(test => $"{test.Key};{Math.Round(test.Value.TotalMilliseconds,0)}")); - - var dotnetVersion = Environment.GetEnvironmentVariable("net_version"); - var cloudEnv = Environment.GetEnvironmentVariable("snowflake_cloud_env"); - - var separator = Path.DirectorySeparatorChar; - - // We have to go up 3 times as the working directory path looks as follows: - // Snowflake.Data.Tests/bin/debug/{.net_version}/ - File.WriteAllText($"..{separator}..{separator}..{separator}{GetOs()}_{dotnetVersion}_{cloudEnv}_performance.csv", resultText); - } +// [OneTimeSetUp] +// public void Setup() +// { +// #if NETFRAMEWORK +// log4net.GlobalContext.Properties["framework"] = "net471"; +// log4net.Config.XmlConfigurator.Configure(); +// +// #else +// log4net.GlobalContext.Properties["framework"] = "net6.0"; +// var logRepository = log4net.LogManager.GetRepository(Assembly.GetEntryAssembly()); +// log4net.Config.XmlConfigurator.Configure(logRepository, new FileInfo("App.config")); +// #endif +// var cloud = Environment.GetEnvironmentVariable("snowflake_cloud_env"); +// Assert.IsTrue(cloud == null || cloud == "AWS" || cloud == "AZURE" || cloud == "GCP", "{0} is not supported. Specify AWS, AZURE or GCP as cloud environment", cloud); +// +// var reader = new StreamReader("parameters.json"); +// +// var testConfigString = reader.ReadToEnd(); +// +// // Local JSON settings to avoid using system wide settings which could be different +// // than the default ones +// var jsonSettings = new JsonSerializerSettings +// { +// ContractResolver = new DefaultContractResolver +// { +// NamingStrategy = new DefaultNamingStrategy() +// } +// }; +// var testConfigs = JsonConvert.DeserializeObject>(testConfigString, jsonSettings); +// +// if (testConfigs.TryGetValue("testconnection", out var testConnectionConfig)) +// { +// TestConfig = testConnectionConfig; +// TestConfig.schema = TestConfig.schema + "_" + Guid.NewGuid().ToString().Replace("-", "_"); +// } +// else +// { +// Assert.Fail("Failed to load test configuration"); +// } +// +// ModifySchema(TestConfig.schema, SchemaAction.CREATE); +// } +// +// [OneTimeTearDown] +// public void Cleanup() +// { +// ModifySchema(TestConfig.schema, SchemaAction.DROP); +// } +// +// [OneTimeSetUp] +// public void SetupTestPerformance() +// { +// s_testPerformance = new Dictionary(); +// } +// +// [OneTimeTearDown] +// public void CreateTestTimeArtifact() +// { +// var resultText = "test;time_in_ms\n"; +// resultText += string.Join("\n", +// s_testPerformance.Select(test => $"{test.Key};{Math.Round(test.Value.TotalMilliseconds,0)}")); +// +// var dotnetVersion = Environment.GetEnvironmentVariable("net_version"); +// var cloudEnv = Environment.GetEnvironmentVariable("snowflake_cloud_env"); +// +// var separator = Path.DirectorySeparatorChar; +// +// // We have to go up 3 times as the working directory path looks as follows: +// // Snowflake.Data.Tests/bin/debug/{.net_version}/ +// File.WriteAllText($"..{separator}..{separator}..{separator}{GetOs()}_{dotnetVersion}_{cloudEnv}_performance.csv", resultText); +// } private static string s_connectionString => string.Format(ConnectionStringFmt, TestConfig.protocol, diff --git a/ci/container/test_authentication.sh b/ci/container/test_authentication.sh index f8b7e9040..da7ea475b 100755 --- a/ci/container/test_authentication.sh +++ b/ci/container/test_authentication.sh @@ -13,12 +13,13 @@ export SNOWFLAKE_AUTH_TEST_PRIVATE_KEY_PATH=./.github/workflows/parameters/rsa_k export SNOWFLAKE_AUTH_TEST_INVALID_PRIVATE_KEY_PATH=./.github/workflows/parameters/rsa_keys/rsa_key_invalid.p8 PARAMETERS_JSON="./Snowflake.Data.Tests/parameters.json" -echo '{ "testconnection": {' > $PARAMETERS_JSON -env | grep '^SNOWFLAKE_TEST' | while IFS='=' read -r key value; do - echo " \"$key\": \"$value\"," >> $PARAMETERS_JSON -done -# Remove the last comma and close the JSON object -awk '{if (NR>1) print prev; prev=$0} END {sub(/,$/, "", prev); print prev}' $PARAMETERS_JSON > tmp && mv tmp $PARAMETERS_JSON -echo '}}' >> $PARAMETERS_JSON +echo '{ "testconnection": { } }' > $PARAMETERS_JSON + +#env | grep '^SNOWFLAKE_TEST' | while IFS='=' read -r key value; do +# echo " \"$key\": \"$value\"," >> $PARAMETERS_JSON +#done +## Remove the last comma and close the JSON object +#awk '{if (NR>1) print prev; prev=$0} END {sub(/,$/, "", prev); print prev}' $PARAMETERS_JSON > tmp && mv tmp $PARAMETERS_JSON +#echo '}}' >> $PARAMETERS_JSON dotnet test -l "console;verbosity=diagnostic" --filter FullyQualifiedName~AuthenticationTests From 554477fe45275eafbc974d9f02f1d278220ad411 Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Tue, 28 Jan 2025 16:24:43 +0100 Subject: [PATCH 23/41] changing name space --- .../AuthConnectionString.cs | 2 +- .../AuthenticationTests/AuthTestHelper.cs | 2 +- .../ExternalBrowserConnection.cs | 28 +-- .../AuthenticationTests/KeyPairConnection.cs | 4 +- .../AuthenticationTests/OauthConnection.cs | 4 +- Snowflake.Data.Tests/SFBaseTest.cs | 178 +++++++++--------- 6 files changed, 109 insertions(+), 109 deletions(-) diff --git a/Snowflake.Data.Tests/AuthenticationTests/AuthConnectionString.cs b/Snowflake.Data.Tests/AuthenticationTests/AuthConnectionString.cs index 459b0a293..33a668609 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/AuthConnectionString.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/AuthConnectionString.cs @@ -7,7 +7,7 @@ using Snowflake.Data.Core; using System.Net.Http; -namespace Snowflake.Data.Tests.AuthenticationTests +namespace Snowflake.Data.AuthenticationTests { static class AuthConnectionString diff --git a/Snowflake.Data.Tests/AuthenticationTests/AuthTestHelper.cs b/Snowflake.Data.Tests/AuthenticationTests/AuthTestHelper.cs index 94660dc10..040674616 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/AuthTestHelper.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/AuthTestHelper.cs @@ -7,7 +7,7 @@ using Snowflake.Data.Log; -namespace Snowflake.Data.Tests.AuthenticationTests +namespace Snowflake.Data.AuthenticationTests { public class AuthTestHelper diff --git a/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs index adb4e1c71..68683a153 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs @@ -6,11 +6,11 @@ using NUnit.Framework; using Snowflake.Data.Core; -namespace Snowflake.Data.Tests.AuthenticationTests +namespace Snowflake.Data.AuthenticationTests { [NonParallelizable] - public class ExternalBrowserConnectionTest : SFBaseTest + public class ExternalBrowserConnectionTest { private string _connectionString = ""; private string _login = AuthConnectionString.SsoUser; @@ -27,18 +27,18 @@ public void SetUp() _connectionString = AuthConnectionString.SetExternalBrowserConnectionString(parameters); } - [Test, IgnoreOnCI] - public void TestAuthenticateUsingExternalBrowserSuccessful() - { - AuthTestHelper authTestHelper = new AuthTestHelper(); - - Thread connectThread = authTestHelper.GetConnectAndExecuteSimpleQueryThread(_connectionString); - Thread provideCredentialsThread = authTestHelper.GetProvideCredentialsThread("success", _login, _password); - - authTestHelper.ConnectAndProvideCredentials(provideCredentialsThread, connectThread); - authTestHelper.VerifyExceptionIsNotThrown(); - - } + // [Test, IgnoreOnCI] + // public void TestAuthenticateUsingExternalBrowserSuccessful() + // { + // AuthTestHelper authTestHelper = new AuthTestHelper(); + // + // Thread connectThread = authTestHelper.GetConnectAndExecuteSimpleQueryThread(_connectionString); + // Thread provideCredentialsThread = authTestHelper.GetProvideCredentialsThread("success", _login, _password); + // + // authTestHelper.ConnectAndProvideCredentials(provideCredentialsThread, connectThread); + // authTestHelper.VerifyExceptionIsNotThrown(); + // + // } // // [Test, IgnoreOnCI] // public void TestAuthenticateUsingExternalBrowserMismatchedUser() diff --git a/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs index c35d79821..2131facf8 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs @@ -4,7 +4,7 @@ using System; using NUnit.Framework; -namespace Snowflake.Data.Tests.AuthenticationTests +namespace Snowflake.Data.AuthenticationTests { [NonParallelizable] @@ -13,7 +13,7 @@ public class KeyPairConnectionTest private string _connectionString = ""; - [Test, IgnoreOnCI] + [Test] public void TestAuthenticateUsingKeyPairFileContentSuccessful() { diff --git a/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs index 6bdc89008..79bcecb0f 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs @@ -5,11 +5,11 @@ using NUnit.Framework; using Snowflake.Data.Core; -namespace Snowflake.Data.Tests.AuthenticationTests +namespace Snowflake.Data.AuthenticationTests { [NonParallelizable] - public class OauthConnectionTest : SFBaseTest + public class OauthConnectionTest { private string _connectionString = ""; diff --git a/Snowflake.Data.Tests/SFBaseTest.cs b/Snowflake.Data.Tests/SFBaseTest.cs index fb26a31f5..cf342e24b 100755 --- a/Snowflake.Data.Tests/SFBaseTest.cs +++ b/Snowflake.Data.Tests/SFBaseTest.cs @@ -70,24 +70,24 @@ public class SFBaseTestAsync private Stopwatch _stopwatch; private List _tablesToRemove; - // - // [SetUp] - // public void BeforeTest() - // { - // _stopwatch = new Stopwatch(); - // _stopwatch.Start(); - // _tablesToRemove = new List(); - // } - // - // [TearDown] - // public void AfterTest() - // { - // _stopwatch.Stop(); - // var testName = $"{TestContext.CurrentContext.Test.FullName}"; - // - // TestEnvironment.RecordTestPerformance(testName, _stopwatch.Elapsed); - // RemoveTables(); - // } + + [SetUp] + public void BeforeTest() + { + _stopwatch = new Stopwatch(); + _stopwatch.Start(); + _tablesToRemove = new List(); + } + + [TearDown] + public void AfterTest() + { + _stopwatch.Stop(); + var testName = $"{TestContext.CurrentContext.Test.FullName}"; + + TestEnvironment.RecordTestPerformance(testName, _stopwatch.Elapsed); + RemoveTables(); + } private void RemoveTables() { @@ -182,77 +182,77 @@ public static void RecordTestPerformance(string name, TimeSpan time) } } -// [OneTimeSetUp] -// public void Setup() -// { -// #if NETFRAMEWORK -// log4net.GlobalContext.Properties["framework"] = "net471"; -// log4net.Config.XmlConfigurator.Configure(); -// -// #else -// log4net.GlobalContext.Properties["framework"] = "net6.0"; -// var logRepository = log4net.LogManager.GetRepository(Assembly.GetEntryAssembly()); -// log4net.Config.XmlConfigurator.Configure(logRepository, new FileInfo("App.config")); -// #endif -// var cloud = Environment.GetEnvironmentVariable("snowflake_cloud_env"); -// Assert.IsTrue(cloud == null || cloud == "AWS" || cloud == "AZURE" || cloud == "GCP", "{0} is not supported. Specify AWS, AZURE or GCP as cloud environment", cloud); -// -// var reader = new StreamReader("parameters.json"); -// -// var testConfigString = reader.ReadToEnd(); -// -// // Local JSON settings to avoid using system wide settings which could be different -// // than the default ones -// var jsonSettings = new JsonSerializerSettings -// { -// ContractResolver = new DefaultContractResolver -// { -// NamingStrategy = new DefaultNamingStrategy() -// } -// }; -// var testConfigs = JsonConvert.DeserializeObject>(testConfigString, jsonSettings); -// -// if (testConfigs.TryGetValue("testconnection", out var testConnectionConfig)) -// { -// TestConfig = testConnectionConfig; -// TestConfig.schema = TestConfig.schema + "_" + Guid.NewGuid().ToString().Replace("-", "_"); -// } -// else -// { -// Assert.Fail("Failed to load test configuration"); -// } -// -// ModifySchema(TestConfig.schema, SchemaAction.CREATE); -// } -// -// [OneTimeTearDown] -// public void Cleanup() -// { -// ModifySchema(TestConfig.schema, SchemaAction.DROP); -// } -// -// [OneTimeSetUp] -// public void SetupTestPerformance() -// { -// s_testPerformance = new Dictionary(); -// } -// -// [OneTimeTearDown] -// public void CreateTestTimeArtifact() -// { -// var resultText = "test;time_in_ms\n"; -// resultText += string.Join("\n", -// s_testPerformance.Select(test => $"{test.Key};{Math.Round(test.Value.TotalMilliseconds,0)}")); -// -// var dotnetVersion = Environment.GetEnvironmentVariable("net_version"); -// var cloudEnv = Environment.GetEnvironmentVariable("snowflake_cloud_env"); -// -// var separator = Path.DirectorySeparatorChar; -// -// // We have to go up 3 times as the working directory path looks as follows: -// // Snowflake.Data.Tests/bin/debug/{.net_version}/ -// File.WriteAllText($"..{separator}..{separator}..{separator}{GetOs()}_{dotnetVersion}_{cloudEnv}_performance.csv", resultText); -// } + [OneTimeSetUp] + public void Setup() + { +#if NETFRAMEWORK + log4net.GlobalContext.Properties["framework"] = "net471"; + log4net.Config.XmlConfigurator.Configure(); + +#else + log4net.GlobalContext.Properties["framework"] = "net6.0"; + var logRepository = log4net.LogManager.GetRepository(Assembly.GetEntryAssembly()); + log4net.Config.XmlConfigurator.Configure(logRepository, new FileInfo("App.config")); +#endif + var cloud = Environment.GetEnvironmentVariable("snowflake_cloud_env"); + Assert.IsTrue(cloud == null || cloud == "AWS" || cloud == "AZURE" || cloud == "GCP", "{0} is not supported. Specify AWS, AZURE or GCP as cloud environment", cloud); + + var reader = new StreamReader("parameters.json"); + + var testConfigString = reader.ReadToEnd(); + + // Local JSON settings to avoid using system wide settings which could be different + // than the default ones + var jsonSettings = new JsonSerializerSettings + { + ContractResolver = new DefaultContractResolver + { + NamingStrategy = new DefaultNamingStrategy() + } + }; + var testConfigs = JsonConvert.DeserializeObject>(testConfigString, jsonSettings); + + if (testConfigs.TryGetValue("testconnection", out var testConnectionConfig)) + { + TestConfig = testConnectionConfig; + TestConfig.schema = TestConfig.schema + "_" + Guid.NewGuid().ToString().Replace("-", "_"); + } + else + { + Assert.Fail("Failed to load test configuration"); + } + + ModifySchema(TestConfig.schema, SchemaAction.CREATE); + } + + [OneTimeTearDown] + public void Cleanup() + { + ModifySchema(TestConfig.schema, SchemaAction.DROP); + } + + [OneTimeSetUp] + public void SetupTestPerformance() + { + s_testPerformance = new Dictionary(); + } + + [OneTimeTearDown] + public void CreateTestTimeArtifact() + { + var resultText = "test;time_in_ms\n"; + resultText += string.Join("\n", + s_testPerformance.Select(test => $"{test.Key};{Math.Round(test.Value.TotalMilliseconds,0)}")); + + var dotnetVersion = Environment.GetEnvironmentVariable("net_version"); + var cloudEnv = Environment.GetEnvironmentVariable("snowflake_cloud_env"); + + var separator = Path.DirectorySeparatorChar; + + // We have to go up 3 times as the working directory path looks as follows: + // Snowflake.Data.Tests/bin/debug/{.net_version}/ + File.WriteAllText($"..{separator}..{separator}..{separator}{GetOs()}_{dotnetVersion}_{cloudEnv}_performance.csv", resultText); + } private static string s_connectionString => string.Format(ConnectionStringFmt, TestConfig.protocol, From e1f0794e7d9fff8ab62dbc696701ae736dc939b0 Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Tue, 28 Jan 2025 16:30:29 +0100 Subject: [PATCH 24/41] oauth test --- .../AuthenticationTests/KeyPairConnection.cs | 25 +++++++++---------- .../AuthenticationTests/OauthConnection.cs | 16 ++++++------ 2 files changed, 20 insertions(+), 21 deletions(-) diff --git a/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs index 2131facf8..ff9150d74 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs @@ -12,19 +12,18 @@ public class KeyPairConnectionTest { private string _connectionString = ""; - - [Test] - public void TestAuthenticateUsingKeyPairFileContentSuccessful() - - { - Console.WriteLine("Before test, after setup"); - AuthTestHelper authTestHelper = new AuthTestHelper(); - var privateKey = AuthConnectionString.GetPrivateKeyContentForKeypairAuth("SNOWFLAKE_AUTH_TEST_PRIVATE_KEY_PATH"); - var parameters = AuthConnectionString.GetKeyPairFromFileContentParameters(privateKey); - _connectionString = AuthConnectionString.SetPrivateKeyFromFileContentConnectionString(parameters); - authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); - authTestHelper.VerifyExceptionIsNotThrown(); - } + // + // [Test] + // public void TestAuthenticateUsingKeyPairFileContentSuccessful() + // + // { + // AuthTestHelper authTestHelper = new AuthTestHelper(); + // var privateKey = AuthConnectionString.GetPrivateKeyContentForKeypairAuth("SNOWFLAKE_AUTH_TEST_PRIVATE_KEY_PATH"); + // var parameters = AuthConnectionString.GetKeyPairFromFileContentParameters(privateKey); + // _connectionString = AuthConnectionString.SetPrivateKeyFromFileContentConnectionString(parameters); + // authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); + // authTestHelper.VerifyExceptionIsNotThrown(); + // } // // [Test, IgnoreOnCI] // public void TestAuthenticateUsingKeyPairFileContentInvalidKey() diff --git a/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs index 79bcecb0f..dc7fd7bbc 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs @@ -22,14 +22,14 @@ public void SetUp() } - // [Test, IgnoreOnCI] - // public void TestAuthenticateUsingOauthSuccessful() - // { - // AuthTestHelper authTestHelper = new AuthTestHelper(); - // - // authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); - // authTestHelper.VerifyExceptionIsNotThrown(); - // } + [Test] + public void TestAuthenticateUsingOauthSuccessful() + { + AuthTestHelper authTestHelper = new AuthTestHelper(); + + authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); + authTestHelper.VerifyExceptionIsNotThrown(); + } // // [Test, IgnoreOnCI] // // public void TestAuthenticateUsingOauthInvalidToken() From 1ba357d4edb1ceead9aa870419d8d679476e14e3 Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Tue, 28 Jan 2025 16:34:29 +0100 Subject: [PATCH 25/41] add externalbrowser --- .../ExternalBrowserConnection.cs | 24 +++++++++---------- 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs index 68683a153..d40366d23 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs @@ -27,18 +27,18 @@ public void SetUp() _connectionString = AuthConnectionString.SetExternalBrowserConnectionString(parameters); } - // [Test, IgnoreOnCI] - // public void TestAuthenticateUsingExternalBrowserSuccessful() - // { - // AuthTestHelper authTestHelper = new AuthTestHelper(); - // - // Thread connectThread = authTestHelper.GetConnectAndExecuteSimpleQueryThread(_connectionString); - // Thread provideCredentialsThread = authTestHelper.GetProvideCredentialsThread("success", _login, _password); - // - // authTestHelper.ConnectAndProvideCredentials(provideCredentialsThread, connectThread); - // authTestHelper.VerifyExceptionIsNotThrown(); - // - // } + [Test] + public void TestAuthenticateUsingExternalBrowserSuccessful() + { + AuthTestHelper authTestHelper = new AuthTestHelper(); + + Thread connectThread = authTestHelper.GetConnectAndExecuteSimpleQueryThread(_connectionString); + Thread provideCredentialsThread = authTestHelper.GetProvideCredentialsThread("success", _login, _password); + + authTestHelper.ConnectAndProvideCredentials(provideCredentialsThread, connectThread); + authTestHelper.VerifyExceptionIsNotThrown(); + + } // // [Test, IgnoreOnCI] // public void TestAuthenticateUsingExternalBrowserMismatchedUser() From 5489a9b9d34acee400ecd7b8861a121a4553f07e Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Wed, 29 Jan 2025 09:01:09 +0100 Subject: [PATCH 26/41] externalbrowser on --- .../ExternalBrowserConnection.cs | 112 +++++++++--------- .../AuthenticationTests/OauthConnection.cs | 24 ++-- 2 files changed, 68 insertions(+), 68 deletions(-) diff --git a/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs index d40366d23..e8af01701 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs @@ -39,61 +39,61 @@ public void TestAuthenticateUsingExternalBrowserSuccessful() authTestHelper.VerifyExceptionIsNotThrown(); } - // - // [Test, IgnoreOnCI] - // public void TestAuthenticateUsingExternalBrowserMismatchedUser() - // { - // AuthTestHelper authTestHelper = new AuthTestHelper(); - // - // var parameters = AuthConnectionString.GetExternalBrowserConnectionString(); - // parameters[SFSessionProperty.USER] = "differentUser"; - // - // _connectionString = AuthConnectionString.SetExternalBrowserConnectionString(parameters); - // - // Thread connectThread = authTestHelper.GetConnectAndExecuteSimpleQueryThread(_connectionString); - // Thread provideCredentialsThread = authTestHelper.GetProvideCredentialsThread("success", _login, _password); - // - // authTestHelper.ConnectAndProvideCredentials(provideCredentialsThread, connectThread); - // authTestHelper.VerifyExceptionIsThrown("The user you were trying to authenticate as differs from the user currently logged in at the IDP"); - // - // } - // - // [Test, IgnoreOnCI] - // public void TestAuthenticateUsingExternalBrowserWrongCredentials() - // { - // AuthTestHelper authTestHelper = new AuthTestHelper(); - // - // var parameters = AuthConnectionString.GetExternalBrowserConnectionString(); - // - // _connectionString = AuthConnectionString.SetExternalBrowserConnectionString(parameters); - // _connectionString += "BROWSER_RESPONSE_TIMEOUT=15;"; - // - // _login = "itsnotanaccount.com"; - // _password = "fakepassword"; - // - // Thread connectThread = authTestHelper.GetConnectAndExecuteSimpleQueryThread(_connectionString); - // Thread provideCredentialsThread = authTestHelper.GetProvideCredentialsThread("fail", _login, _password); - // - // authTestHelper.ConnectAndProvideCredentials(provideCredentialsThread, connectThread); - // authTestHelper.VerifyExceptionIsThrown("Browser response timed out after 15 seconds"); - // - // } - // - // [Test, IgnoreOnCI] - // public void TestAuthenticateUsingExternalBrowserTimeout() - // { - // AuthTestHelper authTestHelper = new AuthTestHelper(); - // - // var parameters = AuthConnectionString.GetExternalBrowserConnectionString(); - // - // _connectionString = AuthConnectionString.SetExternalBrowserConnectionString(parameters); - // _connectionString += "BROWSER_RESPONSE_TIMEOUT=1;"; - // - // Thread connectThread = authTestHelper.GetConnectAndExecuteSimpleQueryThread(_connectionString); - // Thread provideCredentialsThread = authTestHelper.GetProvideCredentialsThread("timeout", _login, _password); - // - // authTestHelper.ConnectAndProvideCredentials(provideCredentialsThread, connectThread); - // authTestHelper.VerifyExceptionIsThrown("Browser response timed out after 1 seconds"); - // } + + [Test] + public void TestAuthenticateUsingExternalBrowserMismatchedUser() + { + AuthTestHelper authTestHelper = new AuthTestHelper(); + + var parameters = AuthConnectionString.GetExternalBrowserConnectionString(); + parameters[SFSessionProperty.USER] = "differentUser"; + + _connectionString = AuthConnectionString.SetExternalBrowserConnectionString(parameters); + + Thread connectThread = authTestHelper.GetConnectAndExecuteSimpleQueryThread(_connectionString); + Thread provideCredentialsThread = authTestHelper.GetProvideCredentialsThread("success", _login, _password); + + authTestHelper.ConnectAndProvideCredentials(provideCredentialsThread, connectThread); + authTestHelper.VerifyExceptionIsThrown("The user you were trying to authenticate as differs from the user currently logged in at the IDP"); + + } + + [Test] + public void TestAuthenticateUsingExternalBrowserWrongCredentials() + { + AuthTestHelper authTestHelper = new AuthTestHelper(); + + var parameters = AuthConnectionString.GetExternalBrowserConnectionString(); + + _connectionString = AuthConnectionString.SetExternalBrowserConnectionString(parameters); + _connectionString += "BROWSER_RESPONSE_TIMEOUT=15;"; + + _login = "itsnotanaccount.com"; + _password = "fakepassword"; + + Thread connectThread = authTestHelper.GetConnectAndExecuteSimpleQueryThread(_connectionString); + Thread provideCredentialsThread = authTestHelper.GetProvideCredentialsThread("fail", _login, _password); + + authTestHelper.ConnectAndProvideCredentials(provideCredentialsThread, connectThread); + authTestHelper.VerifyExceptionIsThrown("Browser response timed out after 15 seconds"); + + } + + [Test] + public void TestAuthenticateUsingExternalBrowserTimeout() + { + AuthTestHelper authTestHelper = new AuthTestHelper(); + + var parameters = AuthConnectionString.GetExternalBrowserConnectionString(); + + _connectionString = AuthConnectionString.SetExternalBrowserConnectionString(parameters); + _connectionString += "BROWSER_RESPONSE_TIMEOUT=1;"; + + Thread connectThread = authTestHelper.GetConnectAndExecuteSimpleQueryThread(_connectionString); + Thread provideCredentialsThread = authTestHelper.GetProvideCredentialsThread("timeout", _login, _password); + + authTestHelper.ConnectAndProvideCredentials(provideCredentialsThread, connectThread); + authTestHelper.VerifyExceptionIsThrown("Browser response timed out after 1 seconds"); + } } } diff --git a/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs index dc7fd7bbc..37f60dabe 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs @@ -31,18 +31,18 @@ public void TestAuthenticateUsingOauthSuccessful() authTestHelper.VerifyExceptionIsNotThrown(); } -// // [Test, IgnoreOnCI] -// // public void TestAuthenticateUsingOauthInvalidToken() -// // { -// // AuthTestHelper authTestHelper = new AuthTestHelper(); -// // -// // string token = "invalidToken"; -// // var parameters = AuthConnectionString.GetOauthConnectionString(token); -// // _connectionString = AuthConnectionString.SetOauthConnectionString(parameters); -// // -// // authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); -// // authTestHelper.VerifyExceptionIsThrown("Invalid OAuth access token"); -// // } + [Test] + public void TestAuthenticateUsingOauthInvalidToken() + { + AuthTestHelper authTestHelper = new AuthTestHelper(); + + string token = "invalidToken"; + var parameters = AuthConnectionString.GetOauthConnectionString(token); + _connectionString = AuthConnectionString.SetOauthConnectionString(parameters); + + authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); + authTestHelper.VerifyExceptionIsThrown("Invalid OAuth access token"); + } // // // [Test, Ignore("Skipped, waits for SNOW-1893041")] // // public void TestAuthenticateUsingOauthMismatchedUser() From 6c2b04fdcf569a048ed24f4486caa4c40d181ea7 Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Wed, 29 Jan 2025 09:08:19 +0100 Subject: [PATCH 27/41] more tests added --- .../AuthenticationTests/KeyPairConnection.cs | 99 +++++---- .../AuthenticationTests/OauthConnection.cs | 30 +-- .../AuthenticationTests/OktaConnection.cs | 188 +++++++++--------- 3 files changed, 158 insertions(+), 159 deletions(-) diff --git a/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs index ff9150d74..18e3697a0 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs @@ -12,55 +12,54 @@ public class KeyPairConnectionTest { private string _connectionString = ""; - // - // [Test] - // public void TestAuthenticateUsingKeyPairFileContentSuccessful() - // - // { - // AuthTestHelper authTestHelper = new AuthTestHelper(); - // var privateKey = AuthConnectionString.GetPrivateKeyContentForKeypairAuth("SNOWFLAKE_AUTH_TEST_PRIVATE_KEY_PATH"); - // var parameters = AuthConnectionString.GetKeyPairFromFileContentParameters(privateKey); - // _connectionString = AuthConnectionString.SetPrivateKeyFromFileContentConnectionString(parameters); - // authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); - // authTestHelper.VerifyExceptionIsNotThrown(); - // } -// -// [Test, IgnoreOnCI] -// public void TestAuthenticateUsingKeyPairFileContentInvalidKey() -// { -// AuthTestHelper authTestHelper = new AuthTestHelper(); -// -// var privateKey = AuthConnectionString.GetPrivateKeyContentForKeypairAuth("SNOWFLAKE_AUTH_TEST_INVALID_PRIVATE_KEY_PATH"); -// var parameters = AuthConnectionString.GetKeyPairFromFileContentParameters(privateKey); -// _connectionString = AuthConnectionString.SetPrivateKeyFromFileContentConnectionString(parameters); -// -// authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); -// authTestHelper.VerifyExceptionIsThrown("Error: JWT token is invalid"); -// } -// -// [Test, IgnoreOnCI] -// public void TestAuthenticateUsingKeyPairFilePathSuccessful() -// { -// AuthTestHelper authTestHelper = new AuthTestHelper(); -// var privateKeyPath = AuthConnectionString.GetPrivateKeyPathForKeypairAuth("SNOWFLAKE_AUTH_TEST_PRIVATE_KEY_PATH"); -// var parameters = AuthConnectionString.GetKeyPairFromFilePathConnectionString(privateKeyPath); -// _connectionString = AuthConnectionString.SetPrivateKeyFromFilePathConnectionString(parameters); -// -// authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); -// authTestHelper.VerifyExceptionIsNotThrown(); -// } -// -// [Test, IgnoreOnCI] -// public void TestAuthenticateUsingKeyPairFilePathInvalidKey() -// { -// AuthTestHelper authTestHelper = new AuthTestHelper(); -// -// var privateKeyPath = AuthConnectionString.GetPrivateKeyPathForKeypairAuth("SNOWFLAKE_AUTH_TEST_INVALID_PRIVATE_KEY_PATH"); -// var parameters = AuthConnectionString.GetKeyPairFromFilePathConnectionString(privateKeyPath); -// _connectionString = AuthConnectionString.SetPrivateKeyFromFilePathConnectionString(parameters); -// -// authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); -// authTestHelper.VerifyExceptionIsThrown("Error: JWT token is invalid"); -// } + [Test] + public void TestAuthenticateUsingKeyPairFileContentSuccessful() + + { + AuthTestHelper authTestHelper = new AuthTestHelper(); + var privateKey = AuthConnectionString.GetPrivateKeyContentForKeypairAuth("SNOWFLAKE_AUTH_TEST_PRIVATE_KEY_PATH"); + var parameters = AuthConnectionString.GetKeyPairFromFileContentParameters(privateKey); + _connectionString = AuthConnectionString.SetPrivateKeyFromFileContentConnectionString(parameters); + authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); + authTestHelper.VerifyExceptionIsNotThrown(); + } + + [Test] + public void TestAuthenticateUsingKeyPairFileContentInvalidKey() + { + AuthTestHelper authTestHelper = new AuthTestHelper(); + + var privateKey = AuthConnectionString.GetPrivateKeyContentForKeypairAuth("SNOWFLAKE_AUTH_TEST_INVALID_PRIVATE_KEY_PATH"); + var parameters = AuthConnectionString.GetKeyPairFromFileContentParameters(privateKey); + _connectionString = AuthConnectionString.SetPrivateKeyFromFileContentConnectionString(parameters); + + authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); + authTestHelper.VerifyExceptionIsThrown("Error: JWT token is invalid"); + } + + [Test] + public void TestAuthenticateUsingKeyPairFilePathSuccessful() + { + AuthTestHelper authTestHelper = new AuthTestHelper(); + var privateKeyPath = AuthConnectionString.GetPrivateKeyPathForKeypairAuth("SNOWFLAKE_AUTH_TEST_PRIVATE_KEY_PATH"); + var parameters = AuthConnectionString.GetKeyPairFromFilePathConnectionString(privateKeyPath); + _connectionString = AuthConnectionString.SetPrivateKeyFromFilePathConnectionString(parameters); + + authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); + authTestHelper.VerifyExceptionIsNotThrown(); + } + + [Test] + public void TestAuthenticateUsingKeyPairFilePathInvalidKey() + { + AuthTestHelper authTestHelper = new AuthTestHelper(); + + var privateKeyPath = AuthConnectionString.GetPrivateKeyPathForKeypairAuth("SNOWFLAKE_AUTH_TEST_INVALID_PRIVATE_KEY_PATH"); + var parameters = AuthConnectionString.GetKeyPairFromFilePathConnectionString(privateKeyPath); + _connectionString = AuthConnectionString.SetPrivateKeyFromFilePathConnectionString(parameters); + + authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); + authTestHelper.VerifyExceptionIsThrown("Error: JWT token is invalid"); + } } } diff --git a/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs index 37f60dabe..6d6fe26a8 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs @@ -43,20 +43,20 @@ public void TestAuthenticateUsingOauthInvalidToken() authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); authTestHelper.VerifyExceptionIsThrown("Invalid OAuth access token"); } -// -// // [Test, Ignore("Skipped, waits for SNOW-1893041")] -// // public void TestAuthenticateUsingOauthMismatchedUser() -// // { -// // AuthTestHelper authTestHelper = new AuthTestHelper(); -// // -// // string token = AuthConnectionString.GetOauthToken(); -// // var parameters = AuthConnectionString.GetOauthConnectionString(token); -// // parameters[SFSessionProperty.USER] = "fakeAccount"; -// // _connectionString = AuthConnectionString.SetOauthConnectionString(parameters) + ";poolingEnabled=false;minPoolSize=0;"; -// // -// // authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); -// // authTestHelper.VerifyExceptionIsThrown("The user you were trying to authenticate as differs from the user tied to the access token"); -// // -// // } + + [Test, Ignore("Skipped, waits for SNOW-1893041")] + public void TestAuthenticateUsingOauthMismatchedUser() + { + AuthTestHelper authTestHelper = new AuthTestHelper(); + + string token = AuthConnectionString.GetOauthToken(); + var parameters = AuthConnectionString.GetOauthConnectionString(token); + parameters[SFSessionProperty.USER] = "fakeAccount"; + _connectionString = AuthConnectionString.SetOauthConnectionString(parameters) + ";poolingEnabled=false;minPoolSize=0;"; + + authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); + authTestHelper.VerifyExceptionIsThrown("The user you were trying to authenticate as differs from the user tied to the access token"); + + } } } diff --git a/Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs index e7f1ebc1d..47d0556f7 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs @@ -1,94 +1,94 @@ -// /* -// * Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved. -// */ -// -// using NUnit.Framework; -// using Snowflake.Data.Core; -// -// namespace Snowflake.Data.Tests.AuthenticationTests -// { -// -// [NonParallelizable] -// public class OktaConnectionTest : SFBaseTest -// { -// private string _connectionString = ""; -// -// [SetUp] -// public void SetUp() -// { -// AuthTestHelper authTestHelper = new AuthTestHelper(); -// -// var parameters = AuthConnectionString.GetOktaConnectionString(); -// _connectionString = AuthConnectionString.SetOktaConnectionString(parameters); -// authTestHelper.CleanBrowserProcess(); -// -// } -// -// [Test, IgnoreOnCI] -// public void TestAuthenticateUsingOktaSuccessful() -// { -// AuthTestHelper authTestHelper = new AuthTestHelper(); -// -// authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); -// authTestHelper.VerifyExceptionIsNotThrown(); -// -// } -// -// [Test, IgnoreOnCI] -// public void TestAuthenticateUsingOktaWrongUsernameParam() -// { -// AuthTestHelper authTestHelper = new AuthTestHelper(); -// -// var parameters = AuthConnectionString.GetOktaConnectionString(); -// parameters[SFSessionProperty.USER] = "differentUser"; -// _connectionString = AuthConnectionString.SetOktaConnectionString(parameters); -// -// authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); -// authTestHelper.VerifyExceptionIsThrown("401 (Unauthorized)"); -// } -// -// [Test, IgnoreOnCI] -// public void TestAuthenticateUsingOktaWrongCredentials() -// { -// AuthTestHelper authTestHelper = new AuthTestHelper(); -// -// var parameters = AuthConnectionString.GetOktaConnectionString(); -// parameters[SFSessionProperty.USER] = "differentUser"; -// parameters[SFSessionProperty.PASSWORD] = "fakepassword"; -// -// _connectionString = AuthConnectionString.SetOktaConnectionString(parameters); -// -// authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); -// authTestHelper.VerifyExceptionIsThrown("401 (Unauthorized)"); -// } -// -// [Test, IgnoreOnCI] -// public void TestAuthenticateUsingOktaWrongUrl() -// { -// AuthTestHelper authTestHelper = new AuthTestHelper(); -// -// var parameters = AuthConnectionString.GetOktaConnectionString(); -// parameters[SFSessionProperty.AUTHENTICATOR] = "https://invalid.okta.com/"; -// -// _connectionString = AuthConnectionString.SetOktaConnectionString(parameters); -// -// authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); -// authTestHelper.VerifyExceptionIsThrown("The specified authenticator is not accepted by your Snowflake account configuration"); -// } -// -// -// [Test, IgnoreOnCI] -// public void TestAuthenticateUsingUrlWithoutOkta() -// { -// AuthTestHelper authTestHelper = new AuthTestHelper(); -// -// var parameters = AuthConnectionString.GetOktaConnectionString(); -// parameters[SFSessionProperty.AUTHENTICATOR] = "https://invalid.abc.com/"; -// -// _connectionString = AuthConnectionString.SetOktaConnectionString(parameters); -// -// authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); -// authTestHelper.VerifyExceptionIsThrown("Unknown authenticator"); -// } -// } -// } +/* + * Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved. + */ + +using NUnit.Framework; +using Snowflake.Data.Core; + +namespace Snowflake.Data.AuthenticationTests +{ + + [NonParallelizable] + public class OktaConnectionTest + { + private string _connectionString = ""; + + [SetUp] + public void SetUp() + { + AuthTestHelper authTestHelper = new AuthTestHelper(); + + var parameters = AuthConnectionString.GetOktaConnectionString(); + _connectionString = AuthConnectionString.SetOktaConnectionString(parameters); + authTestHelper.CleanBrowserProcess(); + + } + + [Test] + public void TestAuthenticateUsingOktaSuccessful() + { + AuthTestHelper authTestHelper = new AuthTestHelper(); + + authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); + authTestHelper.VerifyExceptionIsNotThrown(); + + } + + [Test] + public void TestAuthenticateUsingOktaWrongUsernameParam() + { + AuthTestHelper authTestHelper = new AuthTestHelper(); + + var parameters = AuthConnectionString.GetOktaConnectionString(); + parameters[SFSessionProperty.USER] = "differentUser"; + _connectionString = AuthConnectionString.SetOktaConnectionString(parameters); + + authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); + authTestHelper.VerifyExceptionIsThrown("401 (Unauthorized)"); + } + + [Test] + public void TestAuthenticateUsingOktaWrongCredentials() + { + AuthTestHelper authTestHelper = new AuthTestHelper(); + + var parameters = AuthConnectionString.GetOktaConnectionString(); + parameters[SFSessionProperty.USER] = "differentUser"; + parameters[SFSessionProperty.PASSWORD] = "fakepassword"; + + _connectionString = AuthConnectionString.SetOktaConnectionString(parameters); + + authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); + authTestHelper.VerifyExceptionIsThrown("401 (Unauthorized)"); + } + + [Test] + public void TestAuthenticateUsingOktaWrongUrl() + { + AuthTestHelper authTestHelper = new AuthTestHelper(); + + var parameters = AuthConnectionString.GetOktaConnectionString(); + parameters[SFSessionProperty.AUTHENTICATOR] = "https://invalid.okta.com/"; + + _connectionString = AuthConnectionString.SetOktaConnectionString(parameters); + + authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); + authTestHelper.VerifyExceptionIsThrown("The specified authenticator is not accepted by your Snowflake account configuration"); + } + + + [Test] + public void TestAuthenticateUsingUrlWithoutOkta() + { + AuthTestHelper authTestHelper = new AuthTestHelper(); + + var parameters = AuthConnectionString.GetOktaConnectionString(); + parameters[SFSessionProperty.AUTHENTICATOR] = "https://invalid.abc.com/"; + + _connectionString = AuthConnectionString.SetOktaConnectionString(parameters); + + authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); + authTestHelper.VerifyExceptionIsThrown("Unknown authenticator"); + } + } +} From 45367d1646795796bf727769d4cdbd8cce752364 Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Wed, 29 Jan 2025 09:28:43 +0100 Subject: [PATCH 28/41] specify only .net 9 --- ci/container/test_authentication.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ci/container/test_authentication.sh b/ci/container/test_authentication.sh index da7ea475b..20af64f35 100755 --- a/ci/container/test_authentication.sh +++ b/ci/container/test_authentication.sh @@ -22,4 +22,4 @@ echo '{ "testconnection": { } }' > $PARAMETERS_JSON #awk '{if (NR>1) print prev; prev=$0} END {sub(/,$/, "", prev); print prev}' $PARAMETERS_JSON > tmp && mv tmp $PARAMETERS_JSON #echo '}}' >> $PARAMETERS_JSON -dotnet test -l "console;verbosity=diagnostic" --filter FullyQualifiedName~AuthenticationTests +dotnet test --framework net9.0 -l "console;verbosity=diagnostic" --filter FullyQualifiedName~AuthenticationTests From 69dee964183f6161f34e94841ad9ddc61bb941a1 Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Wed, 29 Jan 2025 09:44:59 +0100 Subject: [PATCH 29/41] ignore on ci import --- .../AuthenticationTests/AuthTestHelper.cs | 8 ++++++++ .../AuthenticationTests/ExternalBrowserConnection.cs | 9 +++++---- .../AuthenticationTests/KeyPairConnection.cs | 10 ++++++---- .../AuthenticationTests/OauthConnection.cs | 5 +++-- .../AuthenticationTests/OktaConnection.cs | 11 ++++++----- 5 files changed, 28 insertions(+), 15 deletions(-) diff --git a/Snowflake.Data.Tests/AuthenticationTests/AuthTestHelper.cs b/Snowflake.Data.Tests/AuthenticationTests/AuthTestHelper.cs index 040674616..9b1cea4f4 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/AuthTestHelper.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/AuthTestHelper.cs @@ -5,6 +5,7 @@ using NUnit.Framework; using Snowflake.Data.Client; using Snowflake.Data.Log; +using Snowflake.Data.Tests; namespace Snowflake.Data.AuthenticationTests @@ -159,6 +160,13 @@ public void ConnectAndProvideCredentials(Thread provideCredentialsThread, Thread connectThread.Join(); } } + + public class IgnoreOnCI : IgnoreOnEnvIsAttribute + { + public IgnoreOnCI(string reason = null) : base("CI", new[] { "true" }, reason) + { + } + } } } diff --git a/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs index e8af01701..5ca7ef079 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs @@ -5,6 +5,7 @@ using System.Threading; using NUnit.Framework; using Snowflake.Data.Core; +using Snowflake.Data.Tests; namespace Snowflake.Data.AuthenticationTests { @@ -27,7 +28,7 @@ public void SetUp() _connectionString = AuthConnectionString.SetExternalBrowserConnectionString(parameters); } - [Test] + [Test, IgnoreOnCI] public void TestAuthenticateUsingExternalBrowserSuccessful() { AuthTestHelper authTestHelper = new AuthTestHelper(); @@ -40,7 +41,7 @@ public void TestAuthenticateUsingExternalBrowserSuccessful() } - [Test] + [Test, IgnoreOnCI] public void TestAuthenticateUsingExternalBrowserMismatchedUser() { AuthTestHelper authTestHelper = new AuthTestHelper(); @@ -58,7 +59,7 @@ public void TestAuthenticateUsingExternalBrowserMismatchedUser() } - [Test] + [Test, IgnoreOnCI] public void TestAuthenticateUsingExternalBrowserWrongCredentials() { AuthTestHelper authTestHelper = new AuthTestHelper(); @@ -79,7 +80,7 @@ public void TestAuthenticateUsingExternalBrowserWrongCredentials() } - [Test] + [Test, IgnoreOnCI] public void TestAuthenticateUsingExternalBrowserTimeout() { AuthTestHelper authTestHelper = new AuthTestHelper(); diff --git a/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs index 18e3697a0..8dfbd9405 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs @@ -4,6 +4,8 @@ using System; using NUnit.Framework; +using Snowflake.Data.Tests; + namespace Snowflake.Data.AuthenticationTests { @@ -12,7 +14,7 @@ public class KeyPairConnectionTest { private string _connectionString = ""; - [Test] + [Test, IgnoreOnCI] public void TestAuthenticateUsingKeyPairFileContentSuccessful() { @@ -24,7 +26,7 @@ public void TestAuthenticateUsingKeyPairFileContentSuccessful() authTestHelper.VerifyExceptionIsNotThrown(); } - [Test] + [Test, IgnoreOnCI] public void TestAuthenticateUsingKeyPairFileContentInvalidKey() { AuthTestHelper authTestHelper = new AuthTestHelper(); @@ -37,7 +39,7 @@ public void TestAuthenticateUsingKeyPairFileContentInvalidKey() authTestHelper.VerifyExceptionIsThrown("Error: JWT token is invalid"); } - [Test] + [Test, IgnoreOnCI] public void TestAuthenticateUsingKeyPairFilePathSuccessful() { AuthTestHelper authTestHelper = new AuthTestHelper(); @@ -49,7 +51,7 @@ public void TestAuthenticateUsingKeyPairFilePathSuccessful() authTestHelper.VerifyExceptionIsNotThrown(); } - [Test] + [Test, IgnoreOnCI] public void TestAuthenticateUsingKeyPairFilePathInvalidKey() { AuthTestHelper authTestHelper = new AuthTestHelper(); diff --git a/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs index 6d6fe26a8..23e3321b5 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs @@ -4,6 +4,7 @@ using NUnit.Framework; using Snowflake.Data.Core; +using Snowflake.Data.Tests; namespace Snowflake.Data.AuthenticationTests { @@ -22,7 +23,7 @@ public void SetUp() } - [Test] + [Test, IgnoreOnCI] public void TestAuthenticateUsingOauthSuccessful() { AuthTestHelper authTestHelper = new AuthTestHelper(); @@ -31,7 +32,7 @@ public void TestAuthenticateUsingOauthSuccessful() authTestHelper.VerifyExceptionIsNotThrown(); } - [Test] + [Test, IgnoreOnCI] public void TestAuthenticateUsingOauthInvalidToken() { AuthTestHelper authTestHelper = new AuthTestHelper(); diff --git a/Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs index 47d0556f7..68950baac 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs @@ -4,6 +4,7 @@ using NUnit.Framework; using Snowflake.Data.Core; +using Snowflake.Data.Tests; namespace Snowflake.Data.AuthenticationTests { @@ -24,7 +25,7 @@ public void SetUp() } - [Test] + [Test, IgnoreOnCI] public void TestAuthenticateUsingOktaSuccessful() { AuthTestHelper authTestHelper = new AuthTestHelper(); @@ -34,7 +35,7 @@ public void TestAuthenticateUsingOktaSuccessful() } - [Test] + [Test, IgnoreOnCI] public void TestAuthenticateUsingOktaWrongUsernameParam() { AuthTestHelper authTestHelper = new AuthTestHelper(); @@ -47,7 +48,7 @@ public void TestAuthenticateUsingOktaWrongUsernameParam() authTestHelper.VerifyExceptionIsThrown("401 (Unauthorized)"); } - [Test] + [Test, IgnoreOnCI] public void TestAuthenticateUsingOktaWrongCredentials() { AuthTestHelper authTestHelper = new AuthTestHelper(); @@ -62,7 +63,7 @@ public void TestAuthenticateUsingOktaWrongCredentials() authTestHelper.VerifyExceptionIsThrown("401 (Unauthorized)"); } - [Test] + [Test, IgnoreOnCI] public void TestAuthenticateUsingOktaWrongUrl() { AuthTestHelper authTestHelper = new AuthTestHelper(); @@ -77,7 +78,7 @@ public void TestAuthenticateUsingOktaWrongUrl() } - [Test] + [Test, IgnoreOnCI] public void TestAuthenticateUsingUrlWithoutOkta() { AuthTestHelper authTestHelper = new AuthTestHelper(); From bee0b3fdfb63a7a326138da7d01758f53fb31cfe Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Wed, 29 Jan 2025 09:49:35 +0100 Subject: [PATCH 30/41] without parameters.json in docker --- ci/container/test_authentication.sh | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/ci/container/test_authentication.sh b/ci/container/test_authentication.sh index 20af64f35..31b9a5490 100755 --- a/ci/container/test_authentication.sh +++ b/ci/container/test_authentication.sh @@ -12,14 +12,4 @@ eval $(jq -r '.authtestparams | to_entries | map("export \(.key)=\(.value|tostri export SNOWFLAKE_AUTH_TEST_PRIVATE_KEY_PATH=./.github/workflows/parameters/rsa_keys/rsa_key.p8 export SNOWFLAKE_AUTH_TEST_INVALID_PRIVATE_KEY_PATH=./.github/workflows/parameters/rsa_keys/rsa_key_invalid.p8 -PARAMETERS_JSON="./Snowflake.Data.Tests/parameters.json" -echo '{ "testconnection": { } }' > $PARAMETERS_JSON - -#env | grep '^SNOWFLAKE_TEST' | while IFS='=' read -r key value; do -# echo " \"$key\": \"$value\"," >> $PARAMETERS_JSON -#done -## Remove the last comma and close the JSON object -#awk '{if (NR>1) print prev; prev=$0} END {sub(/,$/, "", prev); print prev}' $PARAMETERS_JSON > tmp && mv tmp $PARAMETERS_JSON -#echo '}}' >> $PARAMETERS_JSON - dotnet test --framework net9.0 -l "console;verbosity=diagnostic" --filter FullyQualifiedName~AuthenticationTests From 343dc8278e464469df883c3b6562d305857fad0d Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Wed, 29 Jan 2025 09:55:52 +0100 Subject: [PATCH 31/41] test with different namespace --- .../AuthenticationTests/AuthConnectionString.cs | 2 +- Snowflake.Data.Tests/AuthenticationTests/AuthTestHelper.cs | 2 +- .../AuthenticationTests/ExternalBrowserConnection.cs | 2 +- Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs | 2 +- Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs | 2 +- Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs | 2 +- ci/container/test_authentication.sh | 2 +- 7 files changed, 7 insertions(+), 7 deletions(-) diff --git a/Snowflake.Data.Tests/AuthenticationTests/AuthConnectionString.cs b/Snowflake.Data.Tests/AuthenticationTests/AuthConnectionString.cs index 33a668609..459b0a293 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/AuthConnectionString.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/AuthConnectionString.cs @@ -7,7 +7,7 @@ using Snowflake.Data.Core; using System.Net.Http; -namespace Snowflake.Data.AuthenticationTests +namespace Snowflake.Data.Tests.AuthenticationTests { static class AuthConnectionString diff --git a/Snowflake.Data.Tests/AuthenticationTests/AuthTestHelper.cs b/Snowflake.Data.Tests/AuthenticationTests/AuthTestHelper.cs index 9b1cea4f4..c75844137 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/AuthTestHelper.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/AuthTestHelper.cs @@ -8,7 +8,7 @@ using Snowflake.Data.Tests; -namespace Snowflake.Data.AuthenticationTests +namespace Snowflake.Data.Tests.AuthenticationTests { public class AuthTestHelper diff --git a/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs index 5ca7ef079..1047ff6ec 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs @@ -7,7 +7,7 @@ using Snowflake.Data.Core; using Snowflake.Data.Tests; -namespace Snowflake.Data.AuthenticationTests +namespace Snowflake.Data.Tests.AuthenticationTests { [NonParallelizable] diff --git a/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs index 8dfbd9405..fece17f45 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs @@ -6,7 +6,7 @@ using NUnit.Framework; using Snowflake.Data.Tests; -namespace Snowflake.Data.AuthenticationTests +namespace Snowflake.Data.Tests.AuthenticationTests { [NonParallelizable] diff --git a/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs index 23e3321b5..d59600983 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs @@ -6,7 +6,7 @@ using Snowflake.Data.Core; using Snowflake.Data.Tests; -namespace Snowflake.Data.AuthenticationTests +namespace Snowflake.Data.Tests.AuthenticationTests { [NonParallelizable] diff --git a/Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs index 68950baac..e0a119d60 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs @@ -6,7 +6,7 @@ using Snowflake.Data.Core; using Snowflake.Data.Tests; -namespace Snowflake.Data.AuthenticationTests +namespace Snowflake.Data.Tests.AuthenticationTests { [NonParallelizable] diff --git a/ci/container/test_authentication.sh b/ci/container/test_authentication.sh index 31b9a5490..2071695b9 100755 --- a/ci/container/test_authentication.sh +++ b/ci/container/test_authentication.sh @@ -12,4 +12,4 @@ eval $(jq -r '.authtestparams | to_entries | map("export \(.key)=\(.value|tostri export SNOWFLAKE_AUTH_TEST_PRIVATE_KEY_PATH=./.github/workflows/parameters/rsa_keys/rsa_key.p8 export SNOWFLAKE_AUTH_TEST_INVALID_PRIVATE_KEY_PATH=./.github/workflows/parameters/rsa_keys/rsa_key_invalid.p8 -dotnet test --framework net9.0 -l "console;verbosity=diagnostic" --filter FullyQualifiedName~AuthenticationTests +dotnet test --framework net9.0 -l "console;verbosity=info" --filter FullyQualifiedName~AuthenticationTests From 21acb6ebb831f517b2694fd6076006da3a743f7a Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Wed, 29 Jan 2025 10:02:45 +0100 Subject: [PATCH 32/41] cleanup --- .../AuthenticationTests/AuthConnectionString.cs | 2 +- .../AuthenticationTests/AuthTestHelper.cs | 9 +-------- .../AuthenticationTests/ExternalBrowserConnection.cs | 2 +- .../AuthenticationTests/KeyPairConnection.cs | 2 +- .../AuthenticationTests/OauthConnection.cs | 2 +- .../AuthenticationTests/OktaConnection.cs | 2 +- 6 files changed, 6 insertions(+), 13 deletions(-) diff --git a/Snowflake.Data.Tests/AuthenticationTests/AuthConnectionString.cs b/Snowflake.Data.Tests/AuthenticationTests/AuthConnectionString.cs index 459b0a293..33a668609 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/AuthConnectionString.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/AuthConnectionString.cs @@ -7,7 +7,7 @@ using Snowflake.Data.Core; using System.Net.Http; -namespace Snowflake.Data.Tests.AuthenticationTests +namespace Snowflake.Data.AuthenticationTests { static class AuthConnectionString diff --git a/Snowflake.Data.Tests/AuthenticationTests/AuthTestHelper.cs b/Snowflake.Data.Tests/AuthenticationTests/AuthTestHelper.cs index c75844137..8ebcb0b41 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/AuthTestHelper.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/AuthTestHelper.cs @@ -8,7 +8,7 @@ using Snowflake.Data.Tests; -namespace Snowflake.Data.Tests.AuthenticationTests +namespace Snowflake.Data.AuthenticationTests { public class AuthTestHelper @@ -160,13 +160,6 @@ public void ConnectAndProvideCredentials(Thread provideCredentialsThread, Thread connectThread.Join(); } } - - public class IgnoreOnCI : IgnoreOnEnvIsAttribute - { - public IgnoreOnCI(string reason = null) : base("CI", new[] { "true" }, reason) - { - } - } } } diff --git a/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs index 1047ff6ec..5ca7ef079 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs @@ -7,7 +7,7 @@ using Snowflake.Data.Core; using Snowflake.Data.Tests; -namespace Snowflake.Data.Tests.AuthenticationTests +namespace Snowflake.Data.AuthenticationTests { [NonParallelizable] diff --git a/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs index fece17f45..8dfbd9405 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs @@ -6,7 +6,7 @@ using NUnit.Framework; using Snowflake.Data.Tests; -namespace Snowflake.Data.Tests.AuthenticationTests +namespace Snowflake.Data.AuthenticationTests { [NonParallelizable] diff --git a/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs index d59600983..23e3321b5 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs @@ -6,7 +6,7 @@ using Snowflake.Data.Core; using Snowflake.Data.Tests; -namespace Snowflake.Data.Tests.AuthenticationTests +namespace Snowflake.Data.AuthenticationTests { [NonParallelizable] diff --git a/Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs index e0a119d60..68950baac 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs @@ -6,7 +6,7 @@ using Snowflake.Data.Core; using Snowflake.Data.Tests; -namespace Snowflake.Data.Tests.AuthenticationTests +namespace Snowflake.Data.AuthenticationTests { [NonParallelizable] From 6eb6251f69970432ec0e278dc55e74632c6afbf0 Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Wed, 29 Jan 2025 12:33:49 +0100 Subject: [PATCH 33/41] comment oauth test --- .../AuthenticationTests/OauthConnection.cs | 29 +++++++++---------- 1 file changed, 14 insertions(+), 15 deletions(-) diff --git a/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs index 23e3321b5..1ffc1b83e 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs @@ -44,20 +44,19 @@ public void TestAuthenticateUsingOauthInvalidToken() authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); authTestHelper.VerifyExceptionIsThrown("Invalid OAuth access token"); } - - [Test, Ignore("Skipped, waits for SNOW-1893041")] - public void TestAuthenticateUsingOauthMismatchedUser() - { - AuthTestHelper authTestHelper = new AuthTestHelper(); - - string token = AuthConnectionString.GetOauthToken(); - var parameters = AuthConnectionString.GetOauthConnectionString(token); - parameters[SFSessionProperty.USER] = "fakeAccount"; - _connectionString = AuthConnectionString.SetOauthConnectionString(parameters) + ";poolingEnabled=false;minPoolSize=0;"; - - authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); - authTestHelper.VerifyExceptionIsThrown("The user you were trying to authenticate as differs from the user tied to the access token"); - - } + //"Skipped, waits for SNOW-1893041" + // [Test, IgnoreOnCI] + // public void TestAuthenticateUsingOauthMismatchedUser() + // { + // AuthTestHelper authTestHelper = new AuthTestHelper(); + // + // string token = AuthConnectionString.GetOauthToken(); + // var parameters = AuthConnectionString.GetOauthConnectionString(token); + // parameters[SFSessionProperty.USER] = "fakeAccount"; + // _connectionString = AuthConnectionString.SetOauthConnectionString(parameters) + ";poolingEnabled=false;minPoolSize=0;"; + // + // authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); + // authTestHelper.VerifyExceptionIsThrown("The user you were trying to authenticate as differs from the user tied to the access token"); + // } } } From 715d134bc1f3d1c859873c57696b259a80901bfe Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Wed, 29 Jan 2025 13:19:11 +0100 Subject: [PATCH 34/41] ignoreOnCI --- .../AuthenticationTests/ExternalBrowserConnection.cs | 4 ++-- Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs | 2 +- Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs | 4 ++-- Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs | 4 ++-- 4 files changed, 7 insertions(+), 7 deletions(-) diff --git a/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs index 5ca7ef079..3b0d01f1c 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs @@ -10,14 +10,14 @@ namespace Snowflake.Data.AuthenticationTests { - [NonParallelizable] + [NonParallelizable, IgnoreOnCI] public class ExternalBrowserConnectionTest { private string _connectionString = ""; private string _login = AuthConnectionString.SsoUser; private string _password = AuthConnectionString.SsoPassword; - [SetUp] + [SetUp, IgnoreOnCI] public void SetUp() { AuthTestHelper authTestHelper = new AuthTestHelper(); diff --git a/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs index 8dfbd9405..5d5b327b3 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs @@ -9,7 +9,7 @@ namespace Snowflake.Data.AuthenticationTests { - [NonParallelizable] + [NonParallelizable, IgnoreOnCI] public class KeyPairConnectionTest { private string _connectionString = ""; diff --git a/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs index 1ffc1b83e..4fc780d4c 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs @@ -9,12 +9,12 @@ namespace Snowflake.Data.AuthenticationTests { - [NonParallelizable] + [NonParallelizable, IgnoreOnCI] public class OauthConnectionTest { private string _connectionString = ""; - [SetUp] + [SetUp, IgnoreOnCI] public void SetUp() { string token = AuthConnectionString.GetOauthToken(); diff --git a/Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs index 68950baac..e77752acc 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs @@ -9,12 +9,12 @@ namespace Snowflake.Data.AuthenticationTests { - [NonParallelizable] + [NonParallelizable, IgnoreOnCI] public class OktaConnectionTest { private string _connectionString = ""; - [SetUp] + [SetUp, IgnoreOnCI] public void SetUp() { AuthTestHelper authTestHelper = new AuthTestHelper(); From ad5dcacadcc8d6e7b7313b832e356e59bd88bb22 Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Wed, 29 Jan 2025 15:05:47 +0100 Subject: [PATCH 35/41] convert to connection string --- .../AuthConnectionString.cs | 41 +++++++------------ .../ExternalBrowserConnection.cs | 8 ++-- .../AuthenticationTests/KeyPairConnection.cs | 8 ++-- .../AuthenticationTests/OauthConnection.cs | 32 +++++++-------- .../AuthenticationTests/OktaConnection.cs | 10 ++--- 5 files changed, 44 insertions(+), 55 deletions(-) diff --git a/Snowflake.Data.Tests/AuthenticationTests/AuthConnectionString.cs b/Snowflake.Data.Tests/AuthenticationTests/AuthConnectionString.cs index 33a668609..03eee9481 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/AuthConnectionString.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/AuthConnectionString.cs @@ -16,7 +16,7 @@ static class AuthConnectionString public static readonly string Host = Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_HOST"); public static readonly string SsoPassword = Environment.GetEnvironmentVariable("SNOWFLAKE_TEST_OKTA_PASS"); - public static SFSessionProperties GetBaseConnectionString() + private static SFSessionProperties GetBaseConnectionParameters() { var properties = new SFSessionProperties() { @@ -31,37 +31,26 @@ public static SFSessionProperties GetBaseConnectionString() return properties; } - public static string SetBaseConnectionString(SFSessionProperties parameters) => - $"host={parameters[SFSessionProperty.HOST]};port={parameters[SFSessionProperty.PORT]};account={parameters[SFSessionProperty.ACCOUNT]};role={parameters[SFSessionProperty.ROLE]};db={parameters[SFSessionProperty.DB]};schema={parameters[SFSessionProperty.SCHEMA]};warehouse={parameters[SFSessionProperty.WAREHOUSE]};"; - - public static SFSessionProperties GetExternalBrowserConnectionString() { - var properties = GetBaseConnectionString(); + var properties = GetBaseConnectionParameters(); properties.Add(SFSessionProperty.AUTHENTICATOR, "externalbrowser"); properties.Add(SFSessionProperty.USER, Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_BROWSER_USER")); return properties; } - public static string SetExternalBrowserConnectionString(SFSessionProperties parameters) => - $"{SetBaseConnectionString(parameters)}authenticator={parameters[SFSessionProperty.AUTHENTICATOR]};user={parameters[SFSessionProperty.USER]};"; - - public static SFSessionProperties GetOauthConnectionString(string token) { - var properties = GetBaseConnectionString(); + var properties = GetBaseConnectionParameters(); properties.Add(SFSessionProperty.AUTHENTICATOR, "OAUTH"); properties.Add(SFSessionProperty.USER, SsoUser); properties.Add(SFSessionProperty.TOKEN, token); return properties; } - public static string SetOauthConnectionString(SFSessionProperties parameters) => - $"{SetBaseConnectionString(parameters)}authenticator={parameters[SFSessionProperty.AUTHENTICATOR]};user={parameters[SFSessionProperty.USER]};token={parameters[SFSessionProperty.TOKEN]};"; - public static SFSessionProperties GetOktaConnectionString() { - var properties = GetBaseConnectionString(); + var properties = GetBaseConnectionParameters(); properties.Add(SFSessionProperty.AUTHENTICATOR, Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_OAUTH_URL")); properties.Add(SFSessionProperty.USER, SsoUser); properties.Add(SFSessionProperty.PASSWORD, SsoPassword); @@ -72,7 +61,7 @@ public static SFSessionProperties GetOktaConnectionString() public static SFSessionProperties GetKeyPairFromFileContentParameters(string privateKey) { - var properties = GetBaseConnectionString(); + var properties = GetBaseConnectionParameters(); properties.Add(SFSessionProperty.AUTHENTICATOR, "snowflake_jwt"); properties.Add(SFSessionProperty.USER, SsoUser); properties.Add(SFSessionProperty.PRIVATE_KEY, privateKey); @@ -84,23 +73,23 @@ public static SFSessionProperties GetKeyPairFromFileContentParameters(string pri public static SFSessionProperties GetKeyPairFromFilePathConnectionString(string privateKeyPath) { - var properties = GetBaseConnectionString(); + var properties = GetBaseConnectionParameters(); properties.Add(SFSessionProperty.AUTHENTICATOR, "snowflake_jwt"); properties.Add(SFSessionProperty.USER, AuthConnectionString.SsoUser); properties.Add(SFSessionProperty.PRIVATE_KEY_FILE, privateKeyPath); return properties; } - public static string SetPrivateKeyFromFileContentConnectionString(SFSessionProperties parameters) => - $"{SetBaseConnectionString(parameters)}authenticator={parameters[SFSessionProperty.AUTHENTICATOR]};private_key={parameters[SFSessionProperty.PRIVATE_KEY]};user={SsoUser}"; - - public static string SetPrivateKeyFromFilePathConnectionString(SFSessionProperties parameters) => - $"{SetBaseConnectionString(parameters)}authenticator={parameters[SFSessionProperty.AUTHENTICATOR]};private_key_file={parameters[SFSessionProperty.PRIVATE_KEY_FILE]};user={SsoUser}"; - - - public static string SetOktaConnectionString(SFSessionProperties parameters) => - $"{SetBaseConnectionString(parameters)}authenticator={parameters[SFSessionProperty.AUTHENTICATOR]};user={parameters[SFSessionProperty.USER]};password={parameters[SFSessionProperty.PASSWORD]};"; + public static string ConvertToConnectionString(SFSessionProperties properties) + { + StringBuilder connectionStringBuilder = new StringBuilder(); + foreach (var property in properties) + { + connectionStringBuilder.Append($"{property.Key.ToString().ToLower()}={property.Value};"); + } + return connectionStringBuilder.ToString(); + } public static string GetPrivateKeyContentForKeypairAuth(string fileLocation) { diff --git a/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs index 3b0d01f1c..3feb5e898 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs @@ -25,7 +25,7 @@ public void SetUp() _password = AuthConnectionString.SsoPassword; authTestHelper.CleanBrowserProcess(); var parameters = AuthConnectionString.GetExternalBrowserConnectionString(); - _connectionString = AuthConnectionString.SetExternalBrowserConnectionString(parameters); + _connectionString = AuthConnectionString.ConvertToConnectionString(parameters); } [Test, IgnoreOnCI] @@ -49,7 +49,7 @@ public void TestAuthenticateUsingExternalBrowserMismatchedUser() var parameters = AuthConnectionString.GetExternalBrowserConnectionString(); parameters[SFSessionProperty.USER] = "differentUser"; - _connectionString = AuthConnectionString.SetExternalBrowserConnectionString(parameters); + _connectionString = AuthConnectionString.ConvertToConnectionString(parameters); Thread connectThread = authTestHelper.GetConnectAndExecuteSimpleQueryThread(_connectionString); Thread provideCredentialsThread = authTestHelper.GetProvideCredentialsThread("success", _login, _password); @@ -66,7 +66,7 @@ public void TestAuthenticateUsingExternalBrowserWrongCredentials() var parameters = AuthConnectionString.GetExternalBrowserConnectionString(); - _connectionString = AuthConnectionString.SetExternalBrowserConnectionString(parameters); + _connectionString = AuthConnectionString.ConvertToConnectionString(parameters); _connectionString += "BROWSER_RESPONSE_TIMEOUT=15;"; _login = "itsnotanaccount.com"; @@ -87,7 +87,7 @@ public void TestAuthenticateUsingExternalBrowserTimeout() var parameters = AuthConnectionString.GetExternalBrowserConnectionString(); - _connectionString = AuthConnectionString.SetExternalBrowserConnectionString(parameters); + _connectionString = AuthConnectionString.ConvertToConnectionString(parameters); _connectionString += "BROWSER_RESPONSE_TIMEOUT=1;"; Thread connectThread = authTestHelper.GetConnectAndExecuteSimpleQueryThread(_connectionString); diff --git a/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs index 5d5b327b3..feef67a1b 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs @@ -21,7 +21,7 @@ public void TestAuthenticateUsingKeyPairFileContentSuccessful() AuthTestHelper authTestHelper = new AuthTestHelper(); var privateKey = AuthConnectionString.GetPrivateKeyContentForKeypairAuth("SNOWFLAKE_AUTH_TEST_PRIVATE_KEY_PATH"); var parameters = AuthConnectionString.GetKeyPairFromFileContentParameters(privateKey); - _connectionString = AuthConnectionString.SetPrivateKeyFromFileContentConnectionString(parameters); + _connectionString = AuthConnectionString.ConvertToConnectionString(parameters); authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); authTestHelper.VerifyExceptionIsNotThrown(); } @@ -33,7 +33,7 @@ public void TestAuthenticateUsingKeyPairFileContentInvalidKey() var privateKey = AuthConnectionString.GetPrivateKeyContentForKeypairAuth("SNOWFLAKE_AUTH_TEST_INVALID_PRIVATE_KEY_PATH"); var parameters = AuthConnectionString.GetKeyPairFromFileContentParameters(privateKey); - _connectionString = AuthConnectionString.SetPrivateKeyFromFileContentConnectionString(parameters); + _connectionString = AuthConnectionString.ConvertToConnectionString(parameters); authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); authTestHelper.VerifyExceptionIsThrown("Error: JWT token is invalid"); @@ -45,7 +45,7 @@ public void TestAuthenticateUsingKeyPairFilePathSuccessful() AuthTestHelper authTestHelper = new AuthTestHelper(); var privateKeyPath = AuthConnectionString.GetPrivateKeyPathForKeypairAuth("SNOWFLAKE_AUTH_TEST_PRIVATE_KEY_PATH"); var parameters = AuthConnectionString.GetKeyPairFromFilePathConnectionString(privateKeyPath); - _connectionString = AuthConnectionString.SetPrivateKeyFromFilePathConnectionString(parameters); + _connectionString = AuthConnectionString.ConvertToConnectionString(parameters); authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); authTestHelper.VerifyExceptionIsNotThrown(); @@ -58,7 +58,7 @@ public void TestAuthenticateUsingKeyPairFilePathInvalidKey() var privateKeyPath = AuthConnectionString.GetPrivateKeyPathForKeypairAuth("SNOWFLAKE_AUTH_TEST_INVALID_PRIVATE_KEY_PATH"); var parameters = AuthConnectionString.GetKeyPairFromFilePathConnectionString(privateKeyPath); - _connectionString = AuthConnectionString.SetPrivateKeyFromFilePathConnectionString(parameters); + _connectionString = AuthConnectionString.ConvertToConnectionString(parameters); authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); authTestHelper.VerifyExceptionIsThrown("Error: JWT token is invalid"); diff --git a/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs index 4fc780d4c..002057753 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs @@ -19,7 +19,7 @@ public void SetUp() { string token = AuthConnectionString.GetOauthToken(); var parameters = AuthConnectionString.GetOauthConnectionString(token); - _connectionString = AuthConnectionString.SetOauthConnectionString(parameters); + _connectionString = AuthConnectionString.ConvertToConnectionString(parameters); } @@ -39,24 +39,24 @@ public void TestAuthenticateUsingOauthInvalidToken() string token = "invalidToken"; var parameters = AuthConnectionString.GetOauthConnectionString(token); - _connectionString = AuthConnectionString.SetOauthConnectionString(parameters); + _connectionString = AuthConnectionString.ConvertToConnectionString(parameters); authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); authTestHelper.VerifyExceptionIsThrown("Invalid OAuth access token"); } - //"Skipped, waits for SNOW-1893041" - // [Test, IgnoreOnCI] - // public void TestAuthenticateUsingOauthMismatchedUser() - // { - // AuthTestHelper authTestHelper = new AuthTestHelper(); - // - // string token = AuthConnectionString.GetOauthToken(); - // var parameters = AuthConnectionString.GetOauthConnectionString(token); - // parameters[SFSessionProperty.USER] = "fakeAccount"; - // _connectionString = AuthConnectionString.SetOauthConnectionString(parameters) + ";poolingEnabled=false;minPoolSize=0;"; - // - // authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); - // authTestHelper.VerifyExceptionIsThrown("The user you were trying to authenticate as differs from the user tied to the access token"); - // } + + [Test, Ignore("Skipped, waits for SNOW-1893041")] + public void TestAuthenticateUsingOauthMismatchedUser() + { + AuthTestHelper authTestHelper = new AuthTestHelper(); + + string token = AuthConnectionString.GetOauthToken(); + var parameters = AuthConnectionString.GetOauthConnectionString(token); + parameters[SFSessionProperty.USER] = "fakeAccount"; + _connectionString = AuthConnectionString.ConvertToConnectionString(parameters) + ";poolingEnabled=false;minPoolSize=0;"; + + authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); + authTestHelper.VerifyExceptionIsThrown("The user you were trying to authenticate as differs from the user tied to the access token"); + } } } diff --git a/Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs index e77752acc..d79db8bd1 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs @@ -20,7 +20,7 @@ public void SetUp() AuthTestHelper authTestHelper = new AuthTestHelper(); var parameters = AuthConnectionString.GetOktaConnectionString(); - _connectionString = AuthConnectionString.SetOktaConnectionString(parameters); + _connectionString = AuthConnectionString.ConvertToConnectionString(parameters); authTestHelper.CleanBrowserProcess(); } @@ -42,7 +42,7 @@ public void TestAuthenticateUsingOktaWrongUsernameParam() var parameters = AuthConnectionString.GetOktaConnectionString(); parameters[SFSessionProperty.USER] = "differentUser"; - _connectionString = AuthConnectionString.SetOktaConnectionString(parameters); + _connectionString = AuthConnectionString.ConvertToConnectionString(parameters); authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); authTestHelper.VerifyExceptionIsThrown("401 (Unauthorized)"); @@ -57,7 +57,7 @@ public void TestAuthenticateUsingOktaWrongCredentials() parameters[SFSessionProperty.USER] = "differentUser"; parameters[SFSessionProperty.PASSWORD] = "fakepassword"; - _connectionString = AuthConnectionString.SetOktaConnectionString(parameters); + _connectionString = AuthConnectionString.ConvertToConnectionString(parameters); authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); authTestHelper.VerifyExceptionIsThrown("401 (Unauthorized)"); @@ -71,7 +71,7 @@ public void TestAuthenticateUsingOktaWrongUrl() var parameters = AuthConnectionString.GetOktaConnectionString(); parameters[SFSessionProperty.AUTHENTICATOR] = "https://invalid.okta.com/"; - _connectionString = AuthConnectionString.SetOktaConnectionString(parameters); + _connectionString = AuthConnectionString.ConvertToConnectionString(parameters); authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); authTestHelper.VerifyExceptionIsThrown("The specified authenticator is not accepted by your Snowflake account configuration"); @@ -86,7 +86,7 @@ public void TestAuthenticateUsingUrlWithoutOkta() var parameters = AuthConnectionString.GetOktaConnectionString(); parameters[SFSessionProperty.AUTHENTICATOR] = "https://invalid.abc.com/"; - _connectionString = AuthConnectionString.SetOktaConnectionString(parameters); + _connectionString = AuthConnectionString.ConvertToConnectionString(parameters); authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); authTestHelper.VerifyExceptionIsThrown("Unknown authenticator"); From ccb5b975882e572635e7ef033d91727d5709f953 Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Thu, 30 Jan 2025 14:09:51 +0100 Subject: [PATCH 36/41] after review --- .../AuthConnectionString.cs | 15 ++-- .../AuthenticationTests/AuthTestHelper.cs | 90 +++++++------------ ...on.cs => ExternalBrowserConnectionTest.cs} | 57 ++++++------ ...Connection.cs => KeyPairConnectionTest.cs} | 1 + ...thConnection.cs => OauthConnectionTest.cs} | 7 +- ...ktaConnection.cs => OktaConnectionTest.cs} | 0 6 files changed, 72 insertions(+), 98 deletions(-) rename Snowflake.Data.Tests/AuthenticationTests/{ExternalBrowserConnection.cs => ExternalBrowserConnectionTest.cs} (57%) rename Snowflake.Data.Tests/AuthenticationTests/{KeyPairConnection.cs => KeyPairConnectionTest.cs} (99%) rename Snowflake.Data.Tests/AuthenticationTests/{OauthConnection.cs => OauthConnectionTest.cs} (89%) rename Snowflake.Data.Tests/AuthenticationTests/{OktaConnection.cs => OktaConnectionTest.cs} (100%) diff --git a/Snowflake.Data.Tests/AuthenticationTests/AuthConnectionString.cs b/Snowflake.Data.Tests/AuthenticationTests/AuthConnectionString.cs index 03eee9481..7b54e09b9 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/AuthConnectionString.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/AuthConnectionString.cs @@ -101,9 +101,9 @@ public static string GetPrivateKeyContentForKeypairAuth(string fileLocation) } - public static string GetPrivateKeyPathForKeypairAuth(string fileLocation) + public static string GetPrivateKeyPathForKeypairAuth(string relativeFileLocationEnvVariable) { - string filePath = Environment.GetEnvironmentVariable(fileLocation); + string filePath = Environment.GetEnvironmentVariable(relativeFileLocationEnvVariable); Assert.IsNotNull(filePath); return Path.Combine("..", "..", "..", "..", filePath); } @@ -112,13 +112,15 @@ public static string GetOauthToken() { try { - - using (var client = new HttpClient()) + using (var client = new HttpClient(new HttpClientHandler + { + UseCookies = false + })) { var authUrl = Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_OAUTH_URL"); var clientId = Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_OAUTH_CLIENT_ID"); var clientSecret = Environment.GetEnvironmentVariable("SNOWFLAKE_AUTH_TEST_OAUTH_CLIENT_SECRET"); - var credentials = Convert.ToBase64String(Encoding.ASCII.GetBytes($"{clientId}:{clientSecret}")); + var credentials = Convert.ToBase64String(Encoding.UTF8.GetBytes($"{clientId}:{clientSecret}")); client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", credentials); @@ -142,8 +144,7 @@ public static string GetOauthToken() } catch (Exception e) { - Assert.Fail($"Failed to get OAuth token: {e.Message}"); - return null; + throw new Exception($"Failed to get OAuth token: {e.Message}"); } } diff --git a/Snowflake.Data.Tests/AuthenticationTests/AuthTestHelper.cs b/Snowflake.Data.Tests/AuthenticationTests/AuthTestHelper.cs index 8ebcb0b41..dc7f9901f 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/AuthTestHelper.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/AuthTestHelper.cs @@ -5,7 +5,6 @@ using NUnit.Framework; using Snowflake.Data.Client; using Snowflake.Data.Log; -using Snowflake.Data.Tests; namespace Snowflake.Data.AuthenticationTests @@ -23,36 +22,38 @@ public AuthTestHelper() _runAuthTestsManually = bool.Parse(envVar ?? "true"); } - private void ProvideCredentials(string scenario, string login, string password) + private void StartNodeProcess(string path, TimeSpan timeout) { - try + var startInfo = new ProcessStartInfo { - string provideBrowserCredentialsPath = "/externalbrowser/provideBrowserCredentials.js"; - - var startInfo = new ProcessStartInfo - { - FileName = "node", - Arguments = provideBrowserCredentialsPath + " " + scenario + " " + login + " " + password, - RedirectStandardOutput = true, - RedirectStandardError = true, - UseShellExecute = false, - CreateNoWindow = true - }; - using (var process = new Process { StartInfo = startInfo }) + FileName = "node", + Arguments = path, + RedirectStandardOutput = true, + RedirectStandardError = true, + UseShellExecute = false, + CreateNoWindow = true + }; + using (var process = new Process { StartInfo = startInfo }) + { + process.Start(); + if (!process.WaitForExit((int) timeout.TotalMilliseconds)) { - process.Start(); - if (!process.WaitForExit(15000)) // Wait for 15 seconds - { - process.Kill(); - throw new TimeoutException("The process did not complete in the allotted time."); - } + process.Kill(); + throw new TimeoutException("The process did not complete in the allotted time."); + } + string output = process.StandardOutput.ReadToEnd(); + string error = process.StandardError.ReadToEnd(); - string output = process.StandardOutput.ReadToEnd(); - string error = process.StandardError.ReadToEnd(); + s_logger.Info("Output: " + output); + s_logger.Info("Error: " + error); + } + } - s_logger.Info("Output: " + output); - s_logger.Info("Error: " + error); - } + private void ProvideCredentials(string scenario, string login, string password) + { + try + { + StartNodeProcess($"/externalbrowser/provideBrowserCredentials.js {scenario} {login} {password}", TimeSpan.FromSeconds(15)); } catch (Exception e) { @@ -64,37 +65,13 @@ public void CleanBrowserProcess() { if (_runAuthTestsManually) return; + try { - try { - string cleanBrowserProcessesPath = "/externalbrowser/cleanBrowserProcesses.js"; - var startInfo = new ProcessStartInfo - { - FileName = "node", - Arguments = cleanBrowserProcessesPath, - RedirectStandardOutput = true, - RedirectStandardError = true, - UseShellExecute = false, - CreateNoWindow = true - }; - using (var process = new Process { StartInfo = startInfo }) - { - process.Start(); - if (!process.WaitForExit(20000)) // Wait for 20 seconds - { - process.Kill(); - throw new TimeoutException("The process did not complete in the allotted time."); - } - string output = process.StandardOutput.ReadToEnd(); - string error = process.StandardError.ReadToEnd(); - - s_logger.Info("Output: " + output); - s_logger.Info("Error: " + error); - } - } - catch (Exception e) - { - throw new Exception(e.ToString()); - } + StartNodeProcess("/externalbrowser/cleanBrowserProcesses.js", TimeSpan.FromSeconds(20)); + } + catch (Exception e) + { + throw new Exception(e.ToString()); } } @@ -109,7 +86,6 @@ public void ConnectAndExecuteSimpleQuery(string connectionString) conn.Open(); Assert.AreEqual(ConnectionState.Open, conn.State); - using (IDbCommand command = conn.CreateCommand()) { command.CommandText = "SELECT 1"; diff --git a/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnectionTest.cs similarity index 57% rename from Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs rename to Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnectionTest.cs index 3feb5e898..0b146a903 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnectionTest.cs @@ -38,7 +38,6 @@ public void TestAuthenticateUsingExternalBrowserSuccessful() authTestHelper.ConnectAndProvideCredentials(provideCredentialsThread, connectThread); authTestHelper.VerifyExceptionIsNotThrown(); - } [Test, IgnoreOnCI] @@ -56,45 +55,41 @@ public void TestAuthenticateUsingExternalBrowserMismatchedUser() authTestHelper.ConnectAndProvideCredentials(provideCredentialsThread, connectThread); authTestHelper.VerifyExceptionIsThrown("The user you were trying to authenticate as differs from the user currently logged in at the IDP"); - } - [Test, IgnoreOnCI] - public void TestAuthenticateUsingExternalBrowserWrongCredentials() - { - AuthTestHelper authTestHelper = new AuthTestHelper(); - - var parameters = AuthConnectionString.GetExternalBrowserConnectionString(); - - _connectionString = AuthConnectionString.ConvertToConnectionString(parameters); - _connectionString += "BROWSER_RESPONSE_TIMEOUT=15;"; - - _login = "itsnotanaccount.com"; - _password = "fakepassword"; + [Test, IgnoreOnCI] + public void TestAuthenticateUsingExternalBrowserWrongCredentials() + { + AuthTestHelper authTestHelper = new AuthTestHelper(); - Thread connectThread = authTestHelper.GetConnectAndExecuteSimpleQueryThread(_connectionString); - Thread provideCredentialsThread = authTestHelper.GetProvideCredentialsThread("fail", _login, _password); + var parameters = AuthConnectionString.GetExternalBrowserConnectionString(); + parameters.Add(SFSessionProperty.BROWSER_RESPONSE_TIMEOUT, "15"); + _connectionString = AuthConnectionString.ConvertToConnectionString(parameters); - authTestHelper.ConnectAndProvideCredentials(provideCredentialsThread, connectThread); - authTestHelper.VerifyExceptionIsThrown("Browser response timed out after 15 seconds"); + _login = "itsnotanaccount.com"; + _password = "fakepassword"; - } + Thread connectThread = authTestHelper.GetConnectAndExecuteSimpleQueryThread(_connectionString); + Thread provideCredentialsThread = authTestHelper.GetProvideCredentialsThread("fail", _login, _password); - [Test, IgnoreOnCI] - public void TestAuthenticateUsingExternalBrowserTimeout() - { - AuthTestHelper authTestHelper = new AuthTestHelper(); + authTestHelper.ConnectAndProvideCredentials(provideCredentialsThread, connectThread); + authTestHelper.VerifyExceptionIsThrown("Browser response timed out after 15 seconds"); + } - var parameters = AuthConnectionString.GetExternalBrowserConnectionString(); + [Test, IgnoreOnCI] + public void TestAuthenticateUsingExternalBrowserTimeout() + { + AuthTestHelper authTestHelper = new AuthTestHelper(); - _connectionString = AuthConnectionString.ConvertToConnectionString(parameters); - _connectionString += "BROWSER_RESPONSE_TIMEOUT=1;"; + var parameters = AuthConnectionString.GetExternalBrowserConnectionString(); + parameters.Add(SFSessionProperty.BROWSER_RESPONSE_TIMEOUT, "1"); + _connectionString = AuthConnectionString.ConvertToConnectionString(parameters); - Thread connectThread = authTestHelper.GetConnectAndExecuteSimpleQueryThread(_connectionString); - Thread provideCredentialsThread = authTestHelper.GetProvideCredentialsThread("timeout", _login, _password); + Thread connectThread = authTestHelper.GetConnectAndExecuteSimpleQueryThread(_connectionString); + Thread provideCredentialsThread = authTestHelper.GetProvideCredentialsThread("timeout", _login, _password); - authTestHelper.ConnectAndProvideCredentials(provideCredentialsThread, connectThread); - authTestHelper.VerifyExceptionIsThrown("Browser response timed out after 1 seconds"); - } + authTestHelper.ConnectAndProvideCredentials(provideCredentialsThread, connectThread); + authTestHelper.VerifyExceptionIsThrown("Browser response timed out after 1 seconds"); + } } } diff --git a/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnectionTest.cs similarity index 99% rename from Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs rename to Snowflake.Data.Tests/AuthenticationTests/KeyPairConnectionTest.cs index feef67a1b..03dcd11c9 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnectionTest.cs @@ -22,6 +22,7 @@ public void TestAuthenticateUsingKeyPairFileContentSuccessful() var privateKey = AuthConnectionString.GetPrivateKeyContentForKeypairAuth("SNOWFLAKE_AUTH_TEST_PRIVATE_KEY_PATH"); var parameters = AuthConnectionString.GetKeyPairFromFileContentParameters(privateKey); _connectionString = AuthConnectionString.ConvertToConnectionString(parameters); + authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); authTestHelper.VerifyExceptionIsNotThrown(); } diff --git a/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/OauthConnectionTest.cs similarity index 89% rename from Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs rename to Snowflake.Data.Tests/AuthenticationTests/OauthConnectionTest.cs index 002057753..560a3e869 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/OauthConnection.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/OauthConnectionTest.cs @@ -2,6 +2,7 @@ * Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved. */ +using Amazon.Runtime.Internal.Transform; using NUnit.Framework; using Snowflake.Data.Core; using Snowflake.Data.Tests; @@ -20,7 +21,6 @@ public void SetUp() string token = AuthConnectionString.GetOauthToken(); var parameters = AuthConnectionString.GetOauthConnectionString(token); _connectionString = AuthConnectionString.ConvertToConnectionString(parameters); - } [Test, IgnoreOnCI] @@ -52,8 +52,9 @@ public void TestAuthenticateUsingOauthMismatchedUser() string token = AuthConnectionString.GetOauthToken(); var parameters = AuthConnectionString.GetOauthConnectionString(token); - parameters[SFSessionProperty.USER] = "fakeAccount"; - _connectionString = AuthConnectionString.ConvertToConnectionString(parameters) + ";poolingEnabled=false;minPoolSize=0;"; + parameters.Add(SFSessionProperty.USER, "fakeAccount"); + parameters.Add(SFSessionProperty.POOLINGENABLED, "false"); + parameters.Add(SFSessionProperty.MINPOOLSIZE, "0"); authTestHelper.ConnectAndExecuteSimpleQuery(_connectionString); authTestHelper.VerifyExceptionIsThrown("The user you were trying to authenticate as differs from the user tied to the access token"); diff --git a/Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs b/Snowflake.Data.Tests/AuthenticationTests/OktaConnectionTest.cs similarity index 100% rename from Snowflake.Data.Tests/AuthenticationTests/OktaConnection.cs rename to Snowflake.Data.Tests/AuthenticationTests/OktaConnectionTest.cs From 5d8b334e196e50af5235afd243f9d4a0ce6d3e59 Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Thu, 30 Jan 2025 16:05:46 +0100 Subject: [PATCH 37/41] review2 --- .../AuthConnectionString.cs | 1 - .../AuthenticationTests/AuthTestHelper.cs | 99 +++++++++---------- .../ExternalBrowserConnectionTest.cs | 4 - .../KeyPairConnectionTest.cs | 5 - .../OauthConnectionTest.cs | 4 - .../AuthenticationTests/OktaConnectionTest.cs | 4 - 6 files changed, 49 insertions(+), 68 deletions(-) diff --git a/Snowflake.Data.Tests/AuthenticationTests/AuthConnectionString.cs b/Snowflake.Data.Tests/AuthenticationTests/AuthConnectionString.cs index 7b54e09b9..f25bf7b7f 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/AuthConnectionString.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/AuthConnectionString.cs @@ -146,7 +146,6 @@ public static string GetOauthToken() { throw new Exception($"Failed to get OAuth token: {e.Message}"); } - } } } diff --git a/Snowflake.Data.Tests/AuthenticationTests/AuthTestHelper.cs b/Snowflake.Data.Tests/AuthenticationTests/AuthTestHelper.cs index dc7f9901f..cde72dd71 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/AuthTestHelper.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/AuthTestHelper.cs @@ -6,61 +6,11 @@ using Snowflake.Data.Client; using Snowflake.Data.Log; - namespace Snowflake.Data.AuthenticationTests { public class AuthTestHelper { - private static readonly SFLogger s_logger = SFLoggerFactory.GetLogger(); - - private Exception _exception; - private readonly bool _runAuthTestsManually; - public AuthTestHelper() - { - string envVar = Environment.GetEnvironmentVariable("RUN_AUTH_TESTS_MANUALLY"); - _runAuthTestsManually = bool.Parse(envVar ?? "true"); - } - - private void StartNodeProcess(string path, TimeSpan timeout) - { - var startInfo = new ProcessStartInfo - { - FileName = "node", - Arguments = path, - RedirectStandardOutput = true, - RedirectStandardError = true, - UseShellExecute = false, - CreateNoWindow = true - }; - using (var process = new Process { StartInfo = startInfo }) - { - process.Start(); - if (!process.WaitForExit((int) timeout.TotalMilliseconds)) - { - process.Kill(); - throw new TimeoutException("The process did not complete in the allotted time."); - } - string output = process.StandardOutput.ReadToEnd(); - string error = process.StandardError.ReadToEnd(); - - s_logger.Info("Output: " + output); - s_logger.Info("Error: " + error); - } - } - - private void ProvideCredentials(string scenario, string login, string password) - { - try - { - StartNodeProcess($"/externalbrowser/provideBrowserCredentials.js {scenario} {login} {password}", TimeSpan.FromSeconds(15)); - } - catch (Exception e) - { - _exception = e; - } - } - public void CleanBrowserProcess() { if (_runAuthTestsManually) @@ -136,6 +86,55 @@ public void ConnectAndProvideCredentials(Thread provideCredentialsThread, Thread connectThread.Join(); } } + + private static readonly SFLogger s_logger = SFLoggerFactory.GetLogger(); + + private Exception _exception; + private readonly bool _runAuthTestsManually; + public AuthTestHelper() + { + string envVar = Environment.GetEnvironmentVariable("RUN_AUTH_TESTS_MANUALLY"); + _runAuthTestsManually = bool.Parse(envVar ?? "true"); + } + + private void StartNodeProcess(string path, TimeSpan timeout) + { + var startInfo = new ProcessStartInfo + { + FileName = "node", + Arguments = path, + RedirectStandardOutput = true, + RedirectStandardError = true, + UseShellExecute = false, + CreateNoWindow = true + }; + using (var process = new Process { StartInfo = startInfo }) + { + process.Start(); + if (!process.WaitForExit((int) timeout.TotalMilliseconds)) + { + process.Kill(); + throw new TimeoutException("The process did not complete in the allotted time."); + } + string output = process.StandardOutput.ReadToEnd(); + string error = process.StandardError.ReadToEnd(); + + s_logger.Info("Output: " + output); + s_logger.Info("Error: " + error); + } + } + + private void ProvideCredentials(string scenario, string login, string password) + { + try + { + StartNodeProcess($"/externalbrowser/provideBrowserCredentials.js {scenario} {login} {password}", TimeSpan.FromSeconds(15)); + } + catch (Exception e) + { + _exception = e; + } + } } } diff --git a/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnectionTest.cs b/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnectionTest.cs index 0b146a903..1e5f5a04f 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnectionTest.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/ExternalBrowserConnectionTest.cs @@ -1,7 +1,3 @@ -/* - * Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved. - */ - using System.Threading; using NUnit.Framework; using Snowflake.Data.Core; diff --git a/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnectionTest.cs b/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnectionTest.cs index 03dcd11c9..877ff07d1 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnectionTest.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/KeyPairConnectionTest.cs @@ -1,8 +1,3 @@ -/* - * Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved. - */ - -using System; using NUnit.Framework; using Snowflake.Data.Tests; diff --git a/Snowflake.Data.Tests/AuthenticationTests/OauthConnectionTest.cs b/Snowflake.Data.Tests/AuthenticationTests/OauthConnectionTest.cs index 560a3e869..8f662524d 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/OauthConnectionTest.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/OauthConnectionTest.cs @@ -1,7 +1,3 @@ -/* - * Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved. - */ - using Amazon.Runtime.Internal.Transform; using NUnit.Framework; using Snowflake.Data.Core; diff --git a/Snowflake.Data.Tests/AuthenticationTests/OktaConnectionTest.cs b/Snowflake.Data.Tests/AuthenticationTests/OktaConnectionTest.cs index d79db8bd1..e5c837843 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/OktaConnectionTest.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/OktaConnectionTest.cs @@ -1,7 +1,3 @@ -/* - * Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved. - */ - using NUnit.Framework; using Snowflake.Data.Core; using Snowflake.Data.Tests; From 1d01960624be184c4b08daaf37ba57b92240b982 Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Thu, 30 Jan 2025 16:17:40 +0100 Subject: [PATCH 38/41] review3 --- .../AuthenticationTests/AuthConnectionString.cs | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/Snowflake.Data.Tests/AuthenticationTests/AuthConnectionString.cs b/Snowflake.Data.Tests/AuthenticationTests/AuthConnectionString.cs index f25bf7b7f..1647fdadc 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/AuthConnectionString.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/AuthConnectionString.cs @@ -4,8 +4,10 @@ using Newtonsoft.Json.Linq; using NUnit.Framework; using System.IO; +using System.Net; using Snowflake.Data.Core; using System.Net.Http; +using System.Security.Authentication; namespace Snowflake.Data.AuthenticationTests @@ -114,6 +116,10 @@ public static string GetOauthToken() { using (var client = new HttpClient(new HttpClientHandler { + CheckCertificateRevocationList = true, + SslProtocols = SslProtocols.Tls12, + AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate, + UseProxy = false, UseCookies = false })) { From 1aacad4a4e3671b96d646d7ba7abbc5ec17da6ac Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Thu, 30 Jan 2025 16:20:42 +0100 Subject: [PATCH 39/41] review4 --- .../AuthenticationTests/AuthTestHelper.cs | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/Snowflake.Data.Tests/AuthenticationTests/AuthTestHelper.cs b/Snowflake.Data.Tests/AuthenticationTests/AuthTestHelper.cs index cde72dd71..646f56158 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/AuthTestHelper.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/AuthTestHelper.cs @@ -11,6 +11,16 @@ namespace Snowflake.Data.AuthenticationTests public class AuthTestHelper { + private static readonly SFLogger s_logger = SFLoggerFactory.GetLogger(); + private Exception _exception; + private readonly bool _runAuthTestsManually; + + public AuthTestHelper() + { + string envVar = Environment.GetEnvironmentVariable("RUN_AUTH_TESTS_MANUALLY"); + _runAuthTestsManually = bool.Parse(envVar ?? "true"); + } + public void CleanBrowserProcess() { if (_runAuthTestsManually) @@ -87,16 +97,6 @@ public void ConnectAndProvideCredentials(Thread provideCredentialsThread, Thread } } - private static readonly SFLogger s_logger = SFLoggerFactory.GetLogger(); - - private Exception _exception; - private readonly bool _runAuthTestsManually; - public AuthTestHelper() - { - string envVar = Environment.GetEnvironmentVariable("RUN_AUTH_TESTS_MANUALLY"); - _runAuthTestsManually = bool.Parse(envVar ?? "true"); - } - private void StartNodeProcess(string path, TimeSpan timeout) { var startInfo = new ProcessStartInfo From 793cd940dfe851a61a25d48771dccfa7615514c4 Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Thu, 30 Jan 2025 16:22:10 +0100 Subject: [PATCH 40/41] review6 --- Snowflake.Data.Tests/AuthenticationTests/OauthConnectionTest.cs | 1 - 1 file changed, 1 deletion(-) diff --git a/Snowflake.Data.Tests/AuthenticationTests/OauthConnectionTest.cs b/Snowflake.Data.Tests/AuthenticationTests/OauthConnectionTest.cs index 8f662524d..3752e998a 100644 --- a/Snowflake.Data.Tests/AuthenticationTests/OauthConnectionTest.cs +++ b/Snowflake.Data.Tests/AuthenticationTests/OauthConnectionTest.cs @@ -1,4 +1,3 @@ -using Amazon.Runtime.Internal.Transform; using NUnit.Framework; using Snowflake.Data.Core; using Snowflake.Data.Tests; From b75825e39bd479069ea7999157ef109e0aaf69fb Mon Sep 17 00:00:00 2001 From: Patryk Cyrek Date: Thu, 30 Jan 2025 16:33:04 +0100 Subject: [PATCH 41/41] review7 --- ci/test_authentication.sh | 4 ---- 1 file changed, 4 deletions(-) diff --git a/ci/test_authentication.sh b/ci/test_authentication.sh index 0b3ac4495..677517723 100755 --- a/ci/test_authentication.sh +++ b/ci/test_authentication.sh @@ -14,9 +14,6 @@ if [[ -n "$JENKINS_HOME" ]]; then source $CI_DIR/_init.sh source $CI_DIR/scripts/login_internal_docker.sh - echo "Use /sbin/ip" - IP_ADDR=$(/sbin/ip -4 addr show scope global dev eth0 | grep inet | awk '{print $2}' | cut -d / -f 1) - fi gpg --quiet --batch --yes --decrypt --passphrase="$PARAMETERS_SECRET" --output $THIS_DIR/../.github/workflows/parameters/parameters_aws_auth_tests.json "$THIS_DIR/../.github/workflows/parameters/parameters_aws_auth_tests.json.gpg" @@ -27,6 +24,5 @@ docker run \ -v $(cd $THIS_DIR/.. && pwd):/mnt/host \ -v $WORKSPACE:/mnt/workspace \ --rm \ - --platform=linux/amd64 \ nexus.int.snowflakecomputing.com:8086/docker/snowdrivers-test-external-browser-dotnet:1 \ "/mnt/host/ci/container/test_authentication.sh"